Initial commit: Client Doc docs Server Tools

Co-authored-by: Cursor <cursoragent@cursor.com>

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_DOTweenModuleUIWrap.cs

@@ -0,0 +1,67 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class DGTweeningDOTweenModuleUIWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(DG.Tweening.DOTweenModuleUI);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "DG.Tweening.DOTweenModuleUI does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_DOTweenModuleUIWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 396816346195f4346b350d38a01350a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_DOTweenWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 48a5cd86ba40f564bba65265537dd4dd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_ShortcutExtensionsWrap.cs

@@ -0,0 +1,67 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class DGTweeningShortcutExtensionsWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(DG.Tweening.ShortcutExtensions);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "DG.Tweening.ShortcutExtensions does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_ShortcutExtensionsWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c47d5ec9143af7a499367fc6a53ffebc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_TweenExtensionsWrap.cs

@@ -0,0 +1,67 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class DGTweeningTweenExtensionsWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(DG.Tweening.TweenExtensions);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "DG.Tweening.TweenExtensions does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_TweenExtensionsWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 25267979e768f1446bdaa1bc83b0491e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_TweenSettingsExtensionsWrap.cs

@@ -0,0 +1,67 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class DGTweeningTweenSettingsExtensionsWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(DG.Tweening.TweenSettingsExtensions);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "DG.Tweening.TweenSettingsExtensions does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/DG_Tweening_TweenSettingsExtensionsWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b6cb547abb1e0044ab65dc38d8a4669a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/DelegatesGensBridge.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 81ed5c956ebeddf42aa5ad659dbc2008
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/EnumWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cf796762e966e6d46be0f67ff92bc5bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/PackUnpack.cs

@@ -0,0 +1,542 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using System;
+
+
+namespace XLua
+{
+    public static partial class CopyByValue
+    {
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Vector2 val)
+		{
+		    val = new UnityEngine.Vector2();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "x"))
+            {
+			    
+                translator.Get(L, top + 1, out val.x);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "y"))
+            {
+			    
+                translator.Get(L, top + 1, out val.y);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Vector2 field)
+        {
+            
+            if(!LuaAPI.xlua_pack_float2(buff, offset, field.x, field.y))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Vector2 field)
+        {
+            field = default(UnityEngine.Vector2);
+            
+            float x = default(float);
+            float y = default(float);
+            
+            if(!LuaAPI.xlua_unpack_float2(buff, offset, out x, out y))
+            {
+                return false;
+            }
+            field.x = x;
+            field.y = y;
+            
+            
+            return true;
+        }
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Vector3 val)
+		{
+		    val = new UnityEngine.Vector3();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "x"))
+            {
+			    
+                translator.Get(L, top + 1, out val.x);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "y"))
+            {
+			    
+                translator.Get(L, top + 1, out val.y);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "z"))
+            {
+			    
+                translator.Get(L, top + 1, out val.z);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Vector3 field)
+        {
+            
+            if(!LuaAPI.xlua_pack_float3(buff, offset, field.x, field.y, field.z))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Vector3 field)
+        {
+            field = default(UnityEngine.Vector3);
+            
+            float x = default(float);
+            float y = default(float);
+            float z = default(float);
+            
+            if(!LuaAPI.xlua_unpack_float3(buff, offset, out x, out y, out z))
+            {
+                return false;
+            }
+            field.x = x;
+            field.y = y;
+            field.z = z;
+            
+            
+            return true;
+        }
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Vector4 val)
+		{
+		    val = new UnityEngine.Vector4();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "x"))
+            {
+			    
+                translator.Get(L, top + 1, out val.x);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "y"))
+            {
+			    
+                translator.Get(L, top + 1, out val.y);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "z"))
+            {
+			    
+                translator.Get(L, top + 1, out val.z);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "w"))
+            {
+			    
+                translator.Get(L, top + 1, out val.w);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Vector4 field)
+        {
+            
+            if(!LuaAPI.xlua_pack_float4(buff, offset, field.x, field.y, field.z, field.w))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Vector4 field)
+        {
+            field = default(UnityEngine.Vector4);
+            
+            float x = default(float);
+            float y = default(float);
+            float z = default(float);
+            float w = default(float);
+            
+            if(!LuaAPI.xlua_unpack_float4(buff, offset, out x, out y, out z, out w))
+            {
+                return false;
+            }
+            field.x = x;
+            field.y = y;
+            field.z = z;
+            field.w = w;
+            
+            
+            return true;
+        }
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Color val)
+		{
+		    val = new UnityEngine.Color();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "r"))
+            {
+			    
+                translator.Get(L, top + 1, out val.r);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "g"))
+            {
+			    
+                translator.Get(L, top + 1, out val.g);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "b"))
+            {
+			    
+                translator.Get(L, top + 1, out val.b);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "a"))
+            {
+			    
+                translator.Get(L, top + 1, out val.a);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Color field)
+        {
+            
+            if(!LuaAPI.xlua_pack_float4(buff, offset, field.r, field.g, field.b, field.a))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Color field)
+        {
+            field = default(UnityEngine.Color);
+            
+            float r = default(float);
+            float g = default(float);
+            float b = default(float);
+            float a = default(float);
+            
+            if(!LuaAPI.xlua_unpack_float4(buff, offset, out r, out g, out b, out a))
+            {
+                return false;
+            }
+            field.r = r;
+            field.g = g;
+            field.b = b;
+            field.a = a;
+            
+            
+            return true;
+        }
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Quaternion val)
+		{
+		    val = new UnityEngine.Quaternion();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "x"))
+            {
+			    
+                translator.Get(L, top + 1, out val.x);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "y"))
+            {
+			    
+                translator.Get(L, top + 1, out val.y);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "z"))
+            {
+			    
+                translator.Get(L, top + 1, out val.z);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "w"))
+            {
+			    
+                translator.Get(L, top + 1, out val.w);
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Quaternion field)
+        {
+            
+            if(!LuaAPI.xlua_pack_float4(buff, offset, field.x, field.y, field.z, field.w))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Quaternion field)
+        {
+            field = default(UnityEngine.Quaternion);
+            
+            float x = default(float);
+            float y = default(float);
+            float z = default(float);
+            float w = default(float);
+            
+            if(!LuaAPI.xlua_unpack_float4(buff, offset, out x, out y, out z, out w))
+            {
+                return false;
+            }
+            field.x = x;
+            field.y = y;
+            field.z = z;
+            field.w = w;
+            
+            
+            return true;
+        }
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Ray val)
+		{
+		    val = new UnityEngine.Ray();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "origin"))
+            {
+			    
+				var origin = val.origin;
+				translator.Get(L, top + 1, out origin);
+				val.origin = origin;
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "direction"))
+            {
+			    
+				var direction = val.direction;
+				translator.Get(L, top + 1, out direction);
+				val.direction = direction;
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Ray field)
+        {
+            
+            if(!Pack(buff, offset, field.origin))
+            {
+                return false;
+            }
+            
+            if(!Pack(buff, offset + 12, field.direction))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Ray field)
+        {
+            field = default(UnityEngine.Ray);
+            
+            var origin = field.origin;
+            if(!UnPack(buff, offset, out origin))
+            {
+                return false;
+            }
+            field.origin = origin;
+            
+            var direction = field.direction;
+            if(!UnPack(buff, offset + 12, out direction))
+            {
+                return false;
+            }
+            field.direction = direction;
+            
+            return true;
+        }
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Bounds val)
+		{
+		    val = new UnityEngine.Bounds();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "center"))
+            {
+			    
+				var center = val.center;
+				translator.Get(L, top + 1, out center);
+				val.center = center;
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "extents"))
+            {
+			    
+				var extents = val.extents;
+				translator.Get(L, top + 1, out extents);
+				val.extents = extents;
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Bounds field)
+        {
+            
+            if(!Pack(buff, offset, field.center))
+            {
+                return false;
+            }
+            
+            if(!Pack(buff, offset + 12, field.extents))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Bounds field)
+        {
+            field = default(UnityEngine.Bounds);
+            
+            var center = field.center;
+            if(!UnPack(buff, offset, out center))
+            {
+                return false;
+            }
+            field.center = center;
+            
+            var extents = field.extents;
+            if(!UnPack(buff, offset + 12, out extents))
+            {
+                return false;
+            }
+            field.extents = extents;
+            
+            return true;
+        }
+        
+		
+		public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Ray2D val)
+		{
+		    val = new UnityEngine.Ray2D();
+            int top = LuaAPI.lua_gettop(L);
+			
+			if (Utils.LoadField(L, idx, "origin"))
+            {
+			    
+				var origin = val.origin;
+				translator.Get(L, top + 1, out origin);
+				val.origin = origin;
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+			if (Utils.LoadField(L, idx, "direction"))
+            {
+			    
+				var direction = val.direction;
+				translator.Get(L, top + 1, out direction);
+				val.direction = direction;
+				
+            }
+            LuaAPI.lua_pop(L, 1);
+			
+		}
+		
+        public static bool Pack(IntPtr buff, int offset, UnityEngine.Ray2D field)
+        {
+            
+            if(!Pack(buff, offset, field.origin))
+            {
+                return false;
+            }
+            
+            if(!Pack(buff, offset + 8, field.direction))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+        public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Ray2D field)
+        {
+            field = default(UnityEngine.Ray2D);
+            
+            var origin = field.origin;
+            if(!UnPack(buff, offset, out origin))
+            {
+                return false;
+            }
+            field.origin = origin;
+            
+            var direction = field.direction;
+            if(!UnPack(buff, offset + 8, out direction))
+            {
+                return false;
+            }
+            field.direction = direction;
+            
+            return true;
+        }
+        
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/PackUnpack.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fcfd5ef98da6dd04db3485dcedaa2783
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_Enumerator_System_String_System_String_Wrap.cs

@@ -0,0 +1,158 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemCollectionsGenericDictionary_2Enumerator_SystemStringSystemString_Wrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Collections.Generic.Dictionary<string, string>.Enumerator);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveNext", _m_MoveNext);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _m_Dispose);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Current", _g_get_Current);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				
+				if (LuaAPI.lua_gettop(L) == 1)
+				{
+				    translator.Push(L, default(System.Collections.Generic.Dictionary<string, string>.Enumerator));
+			        return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<string, string>.Enumerator constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_MoveNext(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string>.Enumerator gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.MoveNext(  );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.Update(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Dispose(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string>.Enumerator gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.Dispose(  );
+                    
+                    
+                        translator.Update(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Current(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, string>.Enumerator gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.Push(L, gen_to_be_invoked.Current);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_Enumerator_System_String_System_String_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c7caf850e9de0a54aa729df02f9d3f21
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_Int32_System_Int32_Wrap.cs

@@ -0,0 +1,564 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemCollectionsGenericDictionary_2_SystemInt32SystemInt32_Wrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Collections.Generic.Dictionary<int, int>);
+			Utils.BeginObjectRegister(type, L, translator, 0, 11, 4, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsKey", _m_ContainsKey);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsValue", _m_ContainsValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectData", _m_GetObjectData);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeserialization", _m_OnDeserialization);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetValue", _m_TryGetValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureCapacity", _m_EnsureCapacity);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Comparer", _g_get_Comparer);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Keys", _g_get_Keys);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Values", _g_get_Values);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<int, int>();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<int, int>(_capacity);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable<System.Collections.Generic.IEqualityComparer<int>>(L, 2))
+				{
+					System.Collections.Generic.IEqualityComparer<int> _comparer = (System.Collections.Generic.IEqualityComparer<int>)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEqualityComparer<int>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<int, int>(_comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable<System.Collections.Generic.IEqualityComparer<int>>(L, 3))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					System.Collections.Generic.IEqualityComparer<int> _comparer = (System.Collections.Generic.IEqualityComparer<int>)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEqualityComparer<int>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<int, int>(_capacity, _comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<int, int> constructor!");
+            
+        }
+        
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        public static int __CSIndexer(RealStatePtr L)
+        {
+			try {
+			    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				
+				if (translator.Assignable<System.Collections.Generic.Dictionary<int, int>>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					
+					System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+					int index = LuaAPI.xlua_tointeger(L, 2);
+					LuaAPI.lua_pushboolean(L, true);
+					LuaAPI.xlua_pushinteger(L, gen_to_be_invoked[index]);
+					return 2;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+			
+            LuaAPI.lua_pushboolean(L, false);
+			return 1;
+        }
+		
+        
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        public static int __NewIndexer(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+			try {
+				
+				if (translator.Assignable<System.Collections.Generic.Dictionary<int, int>>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3))
+				{
+					
+					System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+					int key = LuaAPI.xlua_tointeger(L, 2);
+					gen_to_be_invoked[key] = LuaAPI.xlua_tointeger(L, 3);
+					LuaAPI.lua_pushboolean(L, true);
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+			
+			LuaAPI.lua_pushboolean(L, false);
+            return 1;
+        }
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Add(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _key = LuaAPI.xlua_tointeger(L, 2);
+                    int _value = LuaAPI.xlua_tointeger(L, 3);
+                    
+                    gen_to_be_invoked.Add( _key, _value );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Clear(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.Clear(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsKey(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _key = LuaAPI.xlua_tointeger(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsKey( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _value = LuaAPI.xlua_tointeger(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsValue( _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetEnumerator(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetEnumerator(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetObjectData(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    System.Runtime.Serialization.SerializationInfo _info = (System.Runtime.Serialization.SerializationInfo)translator.GetObject(L, 2, typeof(System.Runtime.Serialization.SerializationInfo));
+                    System.Runtime.Serialization.StreamingContext _context;translator.Get(L, 3, out _context);
+                    
+                    gen_to_be_invoked.GetObjectData( _info, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_OnDeserialization(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    object _sender = translator.GetObject(L, 2, typeof(object));
+                    
+                    gen_to_be_invoked.OnDeserialization( _sender );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Remove(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _key = LuaAPI.xlua_tointeger(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.Remove( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TryGetValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _key = LuaAPI.xlua_tointeger(L, 2);
+                    int _value;
+                    
+                        var gen_ret = gen_to_be_invoked.TryGetValue( _key, out _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    LuaAPI.xlua_pushinteger(L, _value);
+                        
+                    
+                    
+                    
+                    return 2;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EnsureCapacity(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.EnsureCapacity( _capacity );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TrimExcess(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1) 
+                {
+                    
+                    gen_to_be_invoked.TrimExcess(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                    gen_to_be_invoked.TrimExcess( _capacity );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<int, int>.TrimExcess!");
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Comparer(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.Comparer);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Count(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Keys(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Keys);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Values(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<int, int> gen_to_be_invoked = (System.Collections.Generic.Dictionary<int, int>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Values);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_Int32_System_Int32_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 325f8584dbcf8134e9668a332018db11
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_Int64_System_String_Wrap.cs

@@ -0,0 +1,564 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemCollectionsGenericDictionary_2_SystemInt64SystemString_Wrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Collections.Generic.Dictionary<long, string>);
+			Utils.BeginObjectRegister(type, L, translator, 0, 11, 4, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsKey", _m_ContainsKey);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsValue", _m_ContainsValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectData", _m_GetObjectData);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeserialization", _m_OnDeserialization);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetValue", _m_TryGetValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureCapacity", _m_EnsureCapacity);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Comparer", _g_get_Comparer);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Keys", _g_get_Keys);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Values", _g_get_Values);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<long, string>();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<long, string>(_capacity);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable<System.Collections.Generic.IEqualityComparer<long>>(L, 2))
+				{
+					System.Collections.Generic.IEqualityComparer<long> _comparer = (System.Collections.Generic.IEqualityComparer<long>)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEqualityComparer<long>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<long, string>(_comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable<System.Collections.Generic.IEqualityComparer<long>>(L, 3))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					System.Collections.Generic.IEqualityComparer<long> _comparer = (System.Collections.Generic.IEqualityComparer<long>)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEqualityComparer<long>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<long, string>(_capacity, _comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<long, string> constructor!");
+            
+        }
+        
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        public static int __CSIndexer(RealStatePtr L)
+        {
+			try {
+			    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				
+				if (translator.Assignable<System.Collections.Generic.Dictionary<long, string>>(L, 1) && (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2)))
+				{
+					
+					System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+					long index = LuaAPI.lua_toint64(L, 2);
+					LuaAPI.lua_pushboolean(L, true);
+					LuaAPI.lua_pushstring(L, gen_to_be_invoked[index]);
+					return 2;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+			
+            LuaAPI.lua_pushboolean(L, false);
+			return 1;
+        }
+		
+        
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        public static int __NewIndexer(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+			try {
+				
+				if (translator.Assignable<System.Collections.Generic.Dictionary<long, string>>(L, 1) && (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2)) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))
+				{
+					
+					System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+					long key = LuaAPI.lua_toint64(L, 2);
+					gen_to_be_invoked[key] = LuaAPI.lua_tostring(L, 3);
+					LuaAPI.lua_pushboolean(L, true);
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+			
+			LuaAPI.lua_pushboolean(L, false);
+            return 1;
+        }
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Add(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    long _key = LuaAPI.lua_toint64(L, 2);
+                    string _value = LuaAPI.lua_tostring(L, 3);
+                    
+                    gen_to_be_invoked.Add( _key, _value );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Clear(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.Clear(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsKey(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    long _key = LuaAPI.lua_toint64(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsKey( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _value = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsValue( _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetEnumerator(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetEnumerator(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetObjectData(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    System.Runtime.Serialization.SerializationInfo _info = (System.Runtime.Serialization.SerializationInfo)translator.GetObject(L, 2, typeof(System.Runtime.Serialization.SerializationInfo));
+                    System.Runtime.Serialization.StreamingContext _context;translator.Get(L, 3, out _context);
+                    
+                    gen_to_be_invoked.GetObjectData( _info, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_OnDeserialization(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    object _sender = translator.GetObject(L, 2, typeof(object));
+                    
+                    gen_to_be_invoked.OnDeserialization( _sender );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Remove(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    long _key = LuaAPI.lua_toint64(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.Remove( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TryGetValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    long _key = LuaAPI.lua_toint64(L, 2);
+                    string _value;
+                    
+                        var gen_ret = gen_to_be_invoked.TryGetValue( _key, out _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    LuaAPI.lua_pushstring(L, _value);
+                        
+                    
+                    
+                    
+                    return 2;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EnsureCapacity(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.EnsureCapacity( _capacity );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TrimExcess(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1) 
+                {
+                    
+                    gen_to_be_invoked.TrimExcess(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                    gen_to_be_invoked.TrimExcess( _capacity );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<long, string>.TrimExcess!");
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Comparer(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.Comparer);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Count(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Keys(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Keys);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Values(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<long, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<long, string>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Values);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_Int64_System_String_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1e7d0155c1e74d141ae50c6be25f5763
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_String_System_Object_Wrap.cs

@@ -0,0 +1,572 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemCollectionsGenericDictionary_2_SystemStringSystemObject_Wrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Collections.Generic.Dictionary<string, object>);
+			Utils.BeginObjectRegister(type, L, translator, 0, 13, 4, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "get_Item", _m_get_Item);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "set_Item", _m_set_Item);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsKey", _m_ContainsKey);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsValue", _m_ContainsValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectData", _m_GetObjectData);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeserialization", _m_OnDeserialization);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetValue", _m_TryGetValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureCapacity", _m_EnsureCapacity);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Comparer", _g_get_Comparer);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Keys", _g_get_Keys);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Values", _g_get_Values);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, object>();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, object>(_capacity);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable<System.Collections.Generic.IEqualityComparer<string>>(L, 2))
+				{
+					System.Collections.Generic.IEqualityComparer<string> _comparer = (System.Collections.Generic.IEqualityComparer<string>)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEqualityComparer<string>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, object>(_comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable<System.Collections.Generic.IEqualityComparer<string>>(L, 3))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					System.Collections.Generic.IEqualityComparer<string> _comparer = (System.Collections.Generic.IEqualityComparer<string>)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEqualityComparer<string>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, object>(_capacity, _comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<string, object> constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_get_Item(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+					string key = LuaAPI.lua_tostring(L, 2);
+					translator.PushAny(L, gen_to_be_invoked[key]);
+					
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_set_Item(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+					string key = LuaAPI.lua_tostring(L, 2);
+					object gen_value = translator.GetObject(L, 3, typeof(object));
+                    gen_to_be_invoked[key] = gen_value;
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Add(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    object _value = translator.GetObject(L, 3, typeof(object));
+                    
+                    gen_to_be_invoked.Add( _key, _value );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Clear(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.Clear(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsKey(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsKey( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    object _value = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsValue( _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetEnumerator(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetEnumerator(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetObjectData(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    System.Runtime.Serialization.SerializationInfo _info = (System.Runtime.Serialization.SerializationInfo)translator.GetObject(L, 2, typeof(System.Runtime.Serialization.SerializationInfo));
+                    System.Runtime.Serialization.StreamingContext _context;translator.Get(L, 3, out _context);
+                    
+                    gen_to_be_invoked.GetObjectData( _info, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_OnDeserialization(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    object _sender = translator.GetObject(L, 2, typeof(object));
+                    
+                    gen_to_be_invoked.OnDeserialization( _sender );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Remove(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.Remove( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TryGetValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    object _value;
+                    
+                        var gen_ret = gen_to_be_invoked.TryGetValue( _key, out _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    translator.PushAny(L, _value);
+                        
+                    
+                    
+                    
+                    return 2;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EnsureCapacity(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.EnsureCapacity( _capacity );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TrimExcess(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1) 
+                {
+                    
+                    gen_to_be_invoked.TrimExcess(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                    gen_to_be_invoked.TrimExcess( _capacity );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<string, object>.TrimExcess!");
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Comparer(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.Comparer);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Count(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Keys(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Keys);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Values(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, object> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, object>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Values);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_String_System_Object_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 621496ea15185824dba46b22db63b805
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_String_System_String_Wrap.cs

@@ -0,0 +1,572 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemCollectionsGenericDictionary_2_SystemStringSystemString_Wrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Collections.Generic.Dictionary<string, string>);
+			Utils.BeginObjectRegister(type, L, translator, 0, 13, 4, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "get_Item", _m_get_Item);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "set_Item", _m_set_Item);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsKey", _m_ContainsKey);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsValue", _m_ContainsValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectData", _m_GetObjectData);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeserialization", _m_OnDeserialization);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetValue", _m_TryGetValue);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureCapacity", _m_EnsureCapacity);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Comparer", _g_get_Comparer);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Keys", _g_get_Keys);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Values", _g_get_Values);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, string>();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, string>(_capacity);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable<System.Collections.Generic.IEqualityComparer<string>>(L, 2))
+				{
+					System.Collections.Generic.IEqualityComparer<string> _comparer = (System.Collections.Generic.IEqualityComparer<string>)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEqualityComparer<string>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, string>(_comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable<System.Collections.Generic.IEqualityComparer<string>>(L, 3))
+				{
+					int _capacity = LuaAPI.xlua_tointeger(L, 2);
+					System.Collections.Generic.IEqualityComparer<string> _comparer = (System.Collections.Generic.IEqualityComparer<string>)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEqualityComparer<string>));
+					
+					var gen_ret = new System.Collections.Generic.Dictionary<string, string>(_capacity, _comparer);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<string, string> constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_get_Item(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+					string key = LuaAPI.lua_tostring(L, 2);
+					LuaAPI.lua_pushstring(L, gen_to_be_invoked[key]);
+					
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_set_Item(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+					string key = LuaAPI.lua_tostring(L, 2);
+					string gen_value = LuaAPI.lua_tostring(L, 3);
+                    gen_to_be_invoked[key] = gen_value;
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Add(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    string _value = LuaAPI.lua_tostring(L, 3);
+                    
+                    gen_to_be_invoked.Add( _key, _value );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Clear(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.Clear(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsKey(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsKey( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ContainsValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _value = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ContainsValue( _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetEnumerator(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetEnumerator(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetObjectData(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    System.Runtime.Serialization.SerializationInfo _info = (System.Runtime.Serialization.SerializationInfo)translator.GetObject(L, 2, typeof(System.Runtime.Serialization.SerializationInfo));
+                    System.Runtime.Serialization.StreamingContext _context;translator.Get(L, 3, out _context);
+                    
+                    gen_to_be_invoked.GetObjectData( _info, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_OnDeserialization(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    object _sender = translator.GetObject(L, 2, typeof(object));
+                    
+                    gen_to_be_invoked.OnDeserialization( _sender );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Remove(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.Remove( _key );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TryGetValue(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    string _value;
+                    
+                        var gen_ret = gen_to_be_invoked.TryGetValue( _key, out _value );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    LuaAPI.lua_pushstring(L, _value);
+                        
+                    
+                    
+                    
+                    return 2;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EnsureCapacity(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.EnsureCapacity( _capacity );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TrimExcess(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1) 
+                {
+                    
+                    gen_to_be_invoked.TrimExcess(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
+                {
+                    int _capacity = LuaAPI.xlua_tointeger(L, 2);
+                    
+                    gen_to_be_invoked.TrimExcess( _capacity );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.Dictionary<string, string>.TrimExcess!");
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Comparer(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.Comparer);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Count(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Keys(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Keys);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Values(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.Dictionary<string, string> gen_to_be_invoked = (System.Collections.Generic.Dictionary<string, string>)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.Values);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_Dictionary_2_System_String_System_String_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b031ff1c30a27cd4bb51fbe41b5f138a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_KeyValuePair_2_System_String_System_String_Wrap.cs

@@ -0,0 +1,153 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemCollectionsGenericKeyValuePair_2_SystemStringSystemString_Wrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Collections.Generic.KeyValuePair<string, string>);
+			Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Key", _g_get_Key);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Value", _g_get_Value);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))
+				{
+					string _key = LuaAPI.lua_tostring(L, 2);
+					string _value = LuaAPI.lua_tostring(L, 3);
+					
+					var gen_ret = new System.Collections.Generic.KeyValuePair<string, string>(_key, _value);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+				if (LuaAPI.lua_gettop(L) == 1)
+				{
+				    translator.Push(L, default(System.Collections.Generic.KeyValuePair<string, string>));
+			        return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.KeyValuePair<string, string> constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToString(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.Generic.KeyValuePair<string, string> gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.ToString(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                        translator.Update(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Key(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.KeyValuePair<string, string> gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.Key);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Value(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.Generic.KeyValuePair<string, string> gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.Value);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_KeyValuePair_2_System_String_System_String_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3ddcc45851fad2b499e4d203efb7c308
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_List_1_System_Int32_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: befabad037e69dc49969e0837e29f317
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_List_1_System_String_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 444504dbbd1926946b97bd1764af8de9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_List_1_UnityEngine_Component_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0d1c27281839afe48a0596c3ca8f0e9a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_Generic_List_1_UnityEngine_Vector3_Wrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d639197192fd16e4e9fcba5d84343428
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_IEnumeratorBridge.cs

@@ -0,0 +1,139 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System;
+
+
+namespace XLua.CSObjectWrap
+{
+    public class SystemCollectionsIEnumeratorBridge : LuaBase, System.Collections.IEnumerator
+    {
+	    public static LuaBase __Create(int reference, LuaEnv luaenv)
+		{
+		    return new SystemCollectionsIEnumeratorBridge(reference, luaenv);
+		}
+		
+		public SystemCollectionsIEnumeratorBridge(int reference, LuaEnv luaenv) : base(reference, luaenv)
+        {
+        }
+		
+        
+		bool System.Collections.IEnumerator.MoveNext()
+		{
+#if THREAD_SAFE || HOTFIX_ENABLE
+            lock (luaEnv.luaEnvLock)
+            {
+#endif
+				RealStatePtr L = luaEnv.L;
+				int err_func = LuaAPI.load_error_func(L, luaEnv.errorFuncRef);
+				
+				
+				LuaAPI.lua_getref(L, luaReference);
+				LuaAPI.xlua_pushasciistring(L, "MoveNext");
+				if (0 != LuaAPI.xlua_pgettable(L, -2))
+				{
+					luaEnv.ThrowExceptionFromError(err_func - 1);
+				}
+				if(!LuaAPI.lua_isfunction(L, -1))
+				{
+					LuaAPI.xlua_pushasciistring(L, "no such function MoveNext");
+					luaEnv.ThrowExceptionFromError(err_func - 1);
+				}
+				LuaAPI.lua_pushvalue(L, -2);
+				LuaAPI.lua_remove(L, -3);
+				
+				int __gen_error = LuaAPI.lua_pcall(L, 1, 1, err_func);
+				if (__gen_error != 0)
+					luaEnv.ThrowExceptionFromError(err_func - 1);
+				
+				
+				bool __gen_ret = LuaAPI.lua_toboolean(L, err_func + 1);
+				LuaAPI.lua_settop(L, err_func - 1);
+				return  __gen_ret;
+#if THREAD_SAFE || HOTFIX_ENABLE
+            }
+#endif
+		}
+        
+		void System.Collections.IEnumerator.Reset()
+		{
+#if THREAD_SAFE || HOTFIX_ENABLE
+            lock (luaEnv.luaEnvLock)
+            {
+#endif
+				RealStatePtr L = luaEnv.L;
+				int err_func = LuaAPI.load_error_func(L, luaEnv.errorFuncRef);
+				
+				
+				LuaAPI.lua_getref(L, luaReference);
+				LuaAPI.xlua_pushasciistring(L, "Reset");
+				if (0 != LuaAPI.xlua_pgettable(L, -2))
+				{
+					luaEnv.ThrowExceptionFromError(err_func - 1);
+				}
+				if(!LuaAPI.lua_isfunction(L, -1))
+				{
+					LuaAPI.xlua_pushasciistring(L, "no such function Reset");
+					luaEnv.ThrowExceptionFromError(err_func - 1);
+				}
+				LuaAPI.lua_pushvalue(L, -2);
+				LuaAPI.lua_remove(L, -3);
+				
+				int __gen_error = LuaAPI.lua_pcall(L, 1, 0, err_func);
+				if (__gen_error != 0)
+					luaEnv.ThrowExceptionFromError(err_func - 1);
+				
+				
+				
+				LuaAPI.lua_settop(L, err_func - 1);
+				
+#if THREAD_SAFE || HOTFIX_ENABLE
+            }
+#endif
+		}
+        
+
+        
+        object System.Collections.IEnumerator.Current 
+        {
+            
+            get 
+            {
+#if THREAD_SAFE || HOTFIX_ENABLE
+                lock (luaEnv.luaEnvLock)
+                {
+#endif
+					RealStatePtr L = luaEnv.L;
+					int oldTop = LuaAPI.lua_gettop(L);
+					ObjectTranslator translator = luaEnv.translator;
+					LuaAPI.lua_getref(L, luaReference);
+					LuaAPI.xlua_pushasciistring(L, "Current");
+					if (0 != LuaAPI.xlua_pgettable(L, -2))
+					{
+						luaEnv.ThrowExceptionFromError(oldTop);
+					}
+					object __gen_ret = translator.GetObject(L, -1, typeof(object));
+					LuaAPI.lua_pop(L, 2);
+					return __gen_ret;
+#if THREAD_SAFE || HOTFIX_ENABLE
+                }
+#endif
+            }
+            
+            
+        }
+        
+        
+        
+		
+		
+	}
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_IEnumeratorBridge.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b425aa782e10b7b419911ea3dbbbcf4b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Collections_IEnumeratorWrap.cs

@@ -0,0 +1,139 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemCollectionsIEnumeratorWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Collections.IEnumerator);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveNext", _m_MoveNext);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Current", _g_get_Current);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "System.Collections.IEnumerator does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_MoveNext(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.IEnumerator gen_to_be_invoked = (System.Collections.IEnumerator)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.MoveNext(  );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Reset(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.Collections.IEnumerator gen_to_be_invoked = (System.Collections.IEnumerator)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.Reset(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Current(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.Collections.IEnumerator gen_to_be_invoked = (System.Collections.IEnumerator)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.Current);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Collections_IEnumeratorWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f6c0ce5ace6a32844b04fce8e6305050
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_ConvertWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e2417248c9e286b4b938e2a7953f8a4f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_DateTimeWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e1c21306f9e989b409617230eb2adbc5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Net_DnsWrap.cs

@@ -0,0 +1,367 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemNetDnsWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Net.Dns);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 10, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "BeginGetHostAddresses", _m_BeginGetHostAddresses_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "BeginGetHostEntry", _m_BeginGetHostEntry_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "EndGetHostAddresses", _m_EndGetHostAddresses_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "EndGetHostEntry", _m_EndGetHostEntry_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetHostEntry", _m_GetHostEntry_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetHostAddresses", _m_GetHostAddresses_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetHostName", _m_GetHostName_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetHostAddressesAsync", _m_GetHostAddressesAsync_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetHostEntryAsync", _m_GetHostEntryAsync_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "System.Net.Dns does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_BeginGetHostAddresses_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _hostNameOrAddress = LuaAPI.lua_tostring(L, 1);
+                    System.AsyncCallback _requestCallback = translator.GetDelegate<System.AsyncCallback>(L, 2);
+                    object _state = translator.GetObject(L, 3, typeof(object));
+                    
+                        var gen_ret = System.Net.Dns.BeginGetHostAddresses( _hostNameOrAddress, _requestCallback, _state );
+                        translator.PushAny(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_BeginGetHostEntry_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.AsyncCallback>(L, 2)&& translator.Assignable<object>(L, 3)) 
+                {
+                    string _hostNameOrAddress = LuaAPI.lua_tostring(L, 1);
+                    System.AsyncCallback _requestCallback = translator.GetDelegate<System.AsyncCallback>(L, 2);
+                    object _stateObject = translator.GetObject(L, 3, typeof(object));
+                    
+                        var gen_ret = System.Net.Dns.BeginGetHostEntry( _hostNameOrAddress, _requestCallback, _stateObject );
+                        translator.PushAny(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 3&& translator.Assignable<System.Net.IPAddress>(L, 1)&& translator.Assignable<System.AsyncCallback>(L, 2)&& translator.Assignable<object>(L, 3)) 
+                {
+                    System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 1, typeof(System.Net.IPAddress));
+                    System.AsyncCallback _requestCallback = translator.GetDelegate<System.AsyncCallback>(L, 2);
+                    object _stateObject = translator.GetObject(L, 3, typeof(object));
+                    
+                        var gen_ret = System.Net.Dns.BeginGetHostEntry( _address, _requestCallback, _stateObject );
+                        translator.PushAny(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Net.Dns.BeginGetHostEntry!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EndGetHostAddresses_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    System.IAsyncResult _asyncResult = (System.IAsyncResult)translator.GetObject(L, 1, typeof(System.IAsyncResult));
+                    
+                        var gen_ret = System.Net.Dns.EndGetHostAddresses( _asyncResult );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EndGetHostEntry_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    System.IAsyncResult _asyncResult = (System.IAsyncResult)translator.GetObject(L, 1, typeof(System.IAsyncResult));
+                    
+                        var gen_ret = System.Net.Dns.EndGetHostEntry( _asyncResult );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHostEntry_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
+                {
+                    string _hostNameOrAddress = LuaAPI.lua_tostring(L, 1);
+                    
+                        var gen_ret = System.Net.Dns.GetHostEntry( _hostNameOrAddress );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 1&& translator.Assignable<System.Net.IPAddress>(L, 1)) 
+                {
+                    System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 1, typeof(System.Net.IPAddress));
+                    
+                        var gen_ret = System.Net.Dns.GetHostEntry( _address );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Net.Dns.GetHostEntry!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHostAddresses_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _hostNameOrAddress = LuaAPI.lua_tostring(L, 1);
+                    
+                        var gen_ret = System.Net.Dns.GetHostAddresses( _hostNameOrAddress );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHostName_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                        var gen_ret = System.Net.Dns.GetHostName(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHostAddressesAsync_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _hostNameOrAddress = LuaAPI.lua_tostring(L, 1);
+                    
+                        var gen_ret = System.Net.Dns.GetHostAddressesAsync( _hostNameOrAddress );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHostEntryAsync_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& translator.Assignable<System.Net.IPAddress>(L, 1)) 
+                {
+                    System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 1, typeof(System.Net.IPAddress));
+                    
+                        var gen_ret = System.Net.Dns.GetHostEntryAsync( _address );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
+                {
+                    string _hostNameOrAddress = LuaAPI.lua_tostring(L, 1);
+                    
+                        var gen_ret = System.Net.Dns.GetHostEntryAsync( _hostNameOrAddress );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Net.Dns.GetHostEntryAsync!");
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Net_DnsWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8f375f9c79a6b8e4e95d22a1e92b5ca4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_ObjectWrap.cs

@@ -0,0 +1,259 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemObjectWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(object);
+			Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetType", _m_GetType);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString);
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "Equals", _m_Equals_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ReferenceEquals", _m_ReferenceEquals_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new object();
+					translator.PushAny(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to object constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Equals(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                object gen_to_be_invoked = translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    object _obj = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _obj );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Equals_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    object _objA = translator.GetObject(L, 1, typeof(object));
+                    object _objB = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = object.Equals( _objA, _objB );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHashCode(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                object gen_to_be_invoked = translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetHashCode(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetType(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                object gen_to_be_invoked = translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetType(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToString(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                object gen_to_be_invoked = translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.ToString(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ReferenceEquals_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    object _objA = translator.GetObject(L, 1, typeof(object));
+                    object _objB = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = object.ReferenceEquals( _objA, _objB );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_ObjectWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 10bdf761a39050f45880b35ae667ddbe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_Runtime_CompilerServices_ExtensionAttributeWrap.cs

@@ -0,0 +1,84 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemRuntimeCompilerServicesExtensionAttributeWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.Runtime.CompilerServices.ExtensionAttribute);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new System.Runtime.CompilerServices.ExtensionAttribute();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to System.Runtime.CompilerServices.ExtensionAttribute constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_Runtime_CompilerServices_ExtensionAttributeWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5477c8fef3dde6d4aa13333bf2e733d7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_TimeSpanWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b5886e4be55db34bb0d13ae37379e18
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/System_TimeZoneInfoWrap.cs

@@ -0,0 +1,948 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SystemTimeZoneInfoWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(System.TimeZoneInfo);
+			Utils.BeginObjectRegister(type, L, translator, 0, 11, 6, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAdjustmentRules", _m_GetAdjustmentRules);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAmbiguousTimeOffsets", _m_GetAmbiguousTimeOffsets);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetUtcOffset", _m_GetUtcOffset);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAmbiguousTime", _m_IsAmbiguousTime);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsDaylightSavingTime", _m_IsDaylightSavingTime);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInvalidTime", _m_IsInvalidTime);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasSameRules", _m_HasSameRules);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToSerializedString", _m_ToSerializedString);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Id", _g_get_Id);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DisplayName", _g_get_DisplayName);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "StandardName", _g_get_StandardName);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DaylightName", _g_get_DaylightName);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "BaseUtcOffset", _g_get_BaseUtcOffset);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SupportsDaylightSavingTime", _g_get_SupportsDaylightSavingTime);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 10, 2, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "FindSystemTimeZoneById", _m_FindSystemTimeZoneById_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearCachedData", _m_ClearCachedData_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertTimeBySystemTimeZoneId", _m_ConvertTimeBySystemTimeZoneId_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertTime", _m_ConvertTime_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertTimeFromUtc", _m_ConvertTimeFromUtc_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertTimeToUtc", _m_ConvertTimeToUtc_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "FromSerializedString", _m_FromSerializedString_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSystemTimeZones", _m_GetSystemTimeZones_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateCustomTimeZone", _m_CreateCustomTimeZone_xlua_st_);
+            
+			
+            
+			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Local", _g_get_Local);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Utc", _g_get_Utc);
+            
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "System.TimeZoneInfo does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetAdjustmentRules(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetAdjustmentRules(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_FindSystemTimeZoneById_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _id = LuaAPI.lua_tostring(L, 1);
+                    
+                        var gen_ret = System.TimeZoneInfo.FindSystemTimeZoneById( _id );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetAmbiguousTimeOffsets(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<System.DateTimeOffset>(L, 2)) 
+                {
+                    System.DateTimeOffset _dateTimeOffset;translator.Get(L, 2, out _dateTimeOffset);
+                    
+                        var gen_ret = gen_to_be_invoked.GetAmbiguousTimeOffsets( _dateTimeOffset );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.DateTime>(L, 2)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 2, out _dateTime);
+                    
+                        var gen_ret = gen_to_be_invoked.GetAmbiguousTimeOffsets( _dateTime );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.GetAmbiguousTimeOffsets!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetUtcOffset(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<System.DateTimeOffset>(L, 2)) 
+                {
+                    System.DateTimeOffset _dateTimeOffset;translator.Get(L, 2, out _dateTimeOffset);
+                    
+                        var gen_ret = gen_to_be_invoked.GetUtcOffset( _dateTimeOffset );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.DateTime>(L, 2)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 2, out _dateTime);
+                    
+                        var gen_ret = gen_to_be_invoked.GetUtcOffset( _dateTime );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.GetUtcOffset!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsAmbiguousTime(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<System.DateTimeOffset>(L, 2)) 
+                {
+                    System.DateTimeOffset _dateTimeOffset;translator.Get(L, 2, out _dateTimeOffset);
+                    
+                        var gen_ret = gen_to_be_invoked.IsAmbiguousTime( _dateTimeOffset );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.DateTime>(L, 2)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 2, out _dateTime);
+                    
+                        var gen_ret = gen_to_be_invoked.IsAmbiguousTime( _dateTime );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.IsAmbiguousTime!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsDaylightSavingTime(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<System.DateTimeOffset>(L, 2)) 
+                {
+                    System.DateTimeOffset _dateTimeOffset;translator.Get(L, 2, out _dateTimeOffset);
+                    
+                        var gen_ret = gen_to_be_invoked.IsDaylightSavingTime( _dateTimeOffset );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.DateTime>(L, 2)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 2, out _dateTime);
+                    
+                        var gen_ret = gen_to_be_invoked.IsDaylightSavingTime( _dateTime );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.IsDaylightSavingTime!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsInvalidTime(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    System.DateTime _dateTime;translator.Get(L, 2, out _dateTime);
+                    
+                        var gen_ret = gen_to_be_invoked.IsInvalidTime( _dateTime );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ClearCachedData_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                    System.TimeZoneInfo.ClearCachedData(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ConvertTimeBySystemTimeZoneId_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<System.DateTimeOffset>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
+                {
+                    System.DateTimeOffset _dateTimeOffset;translator.Get(L, 1, out _dateTimeOffset);
+                    string _destinationTimeZoneId = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId( _dateTimeOffset, _destinationTimeZoneId );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.DateTime>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 1, out _dateTime);
+                    string _destinationTimeZoneId = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId( _dateTime, _destinationTimeZoneId );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 3&& translator.Assignable<System.DateTime>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 1, out _dateTime);
+                    string _sourceTimeZoneId = LuaAPI.lua_tostring(L, 2);
+                    string _destinationTimeZoneId = LuaAPI.lua_tostring(L, 3);
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId( _dateTime, _sourceTimeZoneId, _destinationTimeZoneId );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.ConvertTimeBySystemTimeZoneId!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ConvertTime_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<System.DateTimeOffset>(L, 1)&& translator.Assignable<System.TimeZoneInfo>(L, 2)) 
+                {
+                    System.DateTimeOffset _dateTimeOffset;translator.Get(L, 1, out _dateTimeOffset);
+                    System.TimeZoneInfo _destinationTimeZone = (System.TimeZoneInfo)translator.GetObject(L, 2, typeof(System.TimeZoneInfo));
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTime( _dateTimeOffset, _destinationTimeZone );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.DateTime>(L, 1)&& translator.Assignable<System.TimeZoneInfo>(L, 2)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 1, out _dateTime);
+                    System.TimeZoneInfo _destinationTimeZone = (System.TimeZoneInfo)translator.GetObject(L, 2, typeof(System.TimeZoneInfo));
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTime( _dateTime, _destinationTimeZone );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 3&& translator.Assignable<System.DateTime>(L, 1)&& translator.Assignable<System.TimeZoneInfo>(L, 2)&& translator.Assignable<System.TimeZoneInfo>(L, 3)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 1, out _dateTime);
+                    System.TimeZoneInfo _sourceTimeZone = (System.TimeZoneInfo)translator.GetObject(L, 2, typeof(System.TimeZoneInfo));
+                    System.TimeZoneInfo _destinationTimeZone = (System.TimeZoneInfo)translator.GetObject(L, 3, typeof(System.TimeZoneInfo));
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTime( _dateTime, _sourceTimeZone, _destinationTimeZone );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.ConvertTime!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ConvertTimeFromUtc_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    System.DateTime _dateTime;translator.Get(L, 1, out _dateTime);
+                    System.TimeZoneInfo _destinationTimeZone = (System.TimeZoneInfo)translator.GetObject(L, 2, typeof(System.TimeZoneInfo));
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTimeFromUtc( _dateTime, _destinationTimeZone );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ConvertTimeToUtc_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& translator.Assignable<System.DateTime>(L, 1)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 1, out _dateTime);
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTimeToUtc( _dateTime );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.DateTime>(L, 1)&& translator.Assignable<System.TimeZoneInfo>(L, 2)) 
+                {
+                    System.DateTime _dateTime;translator.Get(L, 1, out _dateTime);
+                    System.TimeZoneInfo _sourceTimeZone = (System.TimeZoneInfo)translator.GetObject(L, 2, typeof(System.TimeZoneInfo));
+                    
+                        var gen_ret = System.TimeZoneInfo.ConvertTimeToUtc( _dateTime, _sourceTimeZone );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.ConvertTimeToUtc!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Equals(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<System.TimeZoneInfo>(L, 2)) 
+                {
+                    System.TimeZoneInfo _other = (System.TimeZoneInfo)translator.GetObject(L, 2, typeof(System.TimeZoneInfo));
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _other );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 2)) 
+                {
+                    object _obj = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _obj );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.Equals!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_FromSerializedString_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _source = LuaAPI.lua_tostring(L, 1);
+                    
+                        var gen_ret = System.TimeZoneInfo.FromSerializedString( _source );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHashCode(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetHashCode(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetSystemTimeZones_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    
+                        var gen_ret = System.TimeZoneInfo.GetSystemTimeZones(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_HasSameRules(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    System.TimeZoneInfo _other = (System.TimeZoneInfo)translator.GetObject(L, 2, typeof(System.TimeZoneInfo));
+                    
+                        var gen_ret = gen_to_be_invoked.HasSameRules( _other );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToSerializedString(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.ToSerializedString(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToString(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.ToString(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_CreateCustomTimeZone_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.TimeSpan>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) 
+                {
+                    string _id = LuaAPI.lua_tostring(L, 1);
+                    System.TimeSpan _baseUtcOffset;translator.Get(L, 2, out _baseUtcOffset);
+                    string _displayName = LuaAPI.lua_tostring(L, 3);
+                    string _standardDisplayName = LuaAPI.lua_tostring(L, 4);
+                    
+                        var gen_ret = System.TimeZoneInfo.CreateCustomTimeZone( _id, _baseUtcOffset, _displayName, _standardDisplayName );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.TimeSpan>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.TimeZoneInfo.AdjustmentRule[]>(L, 6)) 
+                {
+                    string _id = LuaAPI.lua_tostring(L, 1);
+                    System.TimeSpan _baseUtcOffset;translator.Get(L, 2, out _baseUtcOffset);
+                    string _displayName = LuaAPI.lua_tostring(L, 3);
+                    string _standardDisplayName = LuaAPI.lua_tostring(L, 4);
+                    string _daylightDisplayName = LuaAPI.lua_tostring(L, 5);
+                    System.TimeZoneInfo.AdjustmentRule[] _adjustmentRules = (System.TimeZoneInfo.AdjustmentRule[])translator.GetObject(L, 6, typeof(System.TimeZoneInfo.AdjustmentRule[]));
+                    
+                        var gen_ret = System.TimeZoneInfo.CreateCustomTimeZone( _id, _baseUtcOffset, _displayName, _standardDisplayName, _daylightDisplayName, _adjustmentRules );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 7&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.TimeSpan>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.TimeZoneInfo.AdjustmentRule[]>(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) 
+                {
+                    string _id = LuaAPI.lua_tostring(L, 1);
+                    System.TimeSpan _baseUtcOffset;translator.Get(L, 2, out _baseUtcOffset);
+                    string _displayName = LuaAPI.lua_tostring(L, 3);
+                    string _standardDisplayName = LuaAPI.lua_tostring(L, 4);
+                    string _daylightDisplayName = LuaAPI.lua_tostring(L, 5);
+                    System.TimeZoneInfo.AdjustmentRule[] _adjustmentRules = (System.TimeZoneInfo.AdjustmentRule[])translator.GetObject(L, 6, typeof(System.TimeZoneInfo.AdjustmentRule[]));
+                    bool _disableDaylightSavingTime = LuaAPI.lua_toboolean(L, 7);
+                    
+                        var gen_ret = System.TimeZoneInfo.CreateCustomTimeZone( _id, _baseUtcOffset, _displayName, _standardDisplayName, _daylightDisplayName, _adjustmentRules, _disableDaylightSavingTime );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to System.TimeZoneInfo.CreateCustomTimeZone!");
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Id(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.Id);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_DisplayName(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.DisplayName);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_StandardName(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.StandardName);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_DaylightName(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.DaylightName);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_BaseUtcOffset(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.BaseUtcOffset);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_SupportsDaylightSavingTime(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                System.TimeZoneInfo gen_to_be_invoked = (System.TimeZoneInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.SupportsDaylightSavingTime);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Local(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.Push(L, System.TimeZoneInfo.Local);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Utc(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.Push(L, System.TimeZoneInfo.Utc);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/System_TimeZoneInfoWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1dbc0abc82d94dd48a39a9c2a492cbdd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AI_NavMeshAgentWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e44d1e03a6edd540a3b2fc1fa69920e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AI_NavMeshObstacleWrap.cs

@@ -0,0 +1,398 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineAINavMeshObstacleWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.AI.NavMeshObstacle);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 10, 10);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "radius", _g_get_radius);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "carving", _g_get_carving);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "carveOnlyStationary", _g_get_carveOnlyStationary);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "carvingMoveThreshold", _g_get_carvingMoveThreshold);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "carvingTimeToStationary", _g_get_carvingTimeToStationary);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "shape", _g_get_shape);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "radius", _s_set_radius);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocity", _s_set_velocity);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "carving", _s_set_carving);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "carveOnlyStationary", _s_set_carveOnlyStationary);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "carvingMoveThreshold", _s_set_carvingMoveThreshold);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "carvingTimeToStationary", _s_set_carvingTimeToStationary);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "shape", _s_set_shape);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.AI.NavMeshObstacle();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AI.NavMeshObstacle constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_height(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.height);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_radius(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radius);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_velocity(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.velocity);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_carving(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.carving);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_carveOnlyStationary(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.carveOnlyStationary);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_carvingMoveThreshold(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.carvingMoveThreshold);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_carvingTimeToStationary(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.carvingTimeToStationary);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_shape(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.shape);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_center(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.center);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_size(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.size);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_height(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.height = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_radius(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.radius = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_velocity(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.velocity = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_carving(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.carving = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_carveOnlyStationary(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.carveOnlyStationary = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_carvingMoveThreshold(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.carvingMoveThreshold = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_carvingTimeToStationary(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.carvingTimeToStationary = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_shape(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                UnityEngine.AI.NavMeshObstacleShape gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.shape = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_center(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.center = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_size(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AI.NavMeshObstacle gen_to_be_invoked = (UnityEngine.AI.NavMeshObstacle)translator.FastGetCSObj(L, 1);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.size = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AI_NavMeshObstacleWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 52bf3f7a54b672e4a946b56560b976cd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AnimationClipWrap.cs

@@ -0,0 +1,493 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineAnimationClipWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.AnimationClip);
+			Utils.BeginObjectRegister(type, L, translator, 0, 5, 12, 5);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SampleAnimation", _m_SampleAnimation);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCurve", _m_SetCurve);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureQuaternionContinuity", _m_EnsureQuaternionContinuity);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCurves", _m_ClearCurves);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddEvent", _m_AddEvent);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameRate", _g_get_frameRate);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "wrapMode", _g_get_wrapMode);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "localBounds", _g_get_localBounds);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "legacy", _g_get_legacy);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "humanMotion", _g_get_humanMotion);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "empty", _g_get_empty);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasGenericRootTransform", _g_get_hasGenericRootTransform);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasMotionFloatCurves", _g_get_hasMotionFloatCurves);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasMotionCurves", _g_get_hasMotionCurves);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasRootCurves", _g_get_hasRootCurves);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "events", _g_get_events);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "frameRate", _s_set_frameRate);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "wrapMode", _s_set_wrapMode);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "localBounds", _s_set_localBounds);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "legacy", _s_set_legacy);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "events", _s_set_events);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.AnimationClip();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AnimationClip constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SampleAnimation(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.GameObject _go = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject));
+                    float _time = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                    gen_to_be_invoked.SampleAnimation( _go, _time );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SetCurve(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _relativePath = LuaAPI.lua_tostring(L, 2);
+                    System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type));
+                    string _propertyName = LuaAPI.lua_tostring(L, 4);
+                    UnityEngine.AnimationCurve _curve = (UnityEngine.AnimationCurve)translator.GetObject(L, 5, typeof(UnityEngine.AnimationCurve));
+                    
+                    gen_to_be_invoked.SetCurve( _relativePath, _type, _propertyName, _curve );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EnsureQuaternionContinuity(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.EnsureQuaternionContinuity(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ClearCurves(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.ClearCurves(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AddEvent(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.AnimationEvent _evt = (UnityEngine.AnimationEvent)translator.GetObject(L, 2, typeof(UnityEngine.AnimationEvent));
+                    
+                    gen_to_be_invoked.AddEvent( _evt );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_length(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_frameRate(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.frameRate);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_wrapMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.wrapMode);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_localBounds(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineBounds(L, gen_to_be_invoked.localBounds);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_legacy(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.legacy);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_humanMotion(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.humanMotion);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_empty(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.empty);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_hasGenericRootTransform(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasGenericRootTransform);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_hasMotionFloatCurves(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasMotionFloatCurves);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_hasMotionCurves(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasMotionCurves);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_hasRootCurves(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasRootCurves);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_events(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.events);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_frameRate(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.frameRate = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_wrapMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                UnityEngine.WrapMode gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.wrapMode = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_localBounds(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                UnityEngine.Bounds gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.localBounds = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_legacy(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.legacy = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_events(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.events = (UnityEngine.AnimationEvent[])translator.GetObject(L, 2, typeof(UnityEngine.AnimationEvent[]));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AnimationClipWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c0cea95fea273d6449b724c599b3c1d6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AnimationCurveWrap.cs

@@ -0,0 +1,617 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineAnimationCurveWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.AnimationCurve);
+			Utils.BeginObjectRegister(type, L, translator, 0, 9, 4, 3);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Evaluate", _m_Evaluate);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddKey", _m_AddKey);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveKey", _m_MoveKey);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearKeys", _m_ClearKeys);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveKey", _m_RemoveKey);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SmoothTangents", _m_SmoothTangents);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyFrom", _m_CopyFrom);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "keys", _g_get_keys);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "preWrapMode", _g_get_preWrapMode);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "postWrapMode", _g_get_postWrapMode);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "keys", _s_set_keys);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "preWrapMode", _s_set_preWrapMode);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "postWrapMode", _s_set_postWrapMode);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, __CSIndexer, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "Constant", _m_Constant_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "Linear", _m_Linear_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "EaseInOut", _m_EaseInOut_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) >= 1 && (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable<UnityEngine.Keyframe>(L, 2)))
+				{
+					UnityEngine.Keyframe[] _keys = translator.GetParams<UnityEngine.Keyframe>(L, 2);
+					
+					var gen_ret = new UnityEngine.AnimationCurve(_keys);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.AnimationCurve();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AnimationCurve constructor!");
+            
+        }
+        
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        public static int __CSIndexer(RealStatePtr L)
+        {
+			try {
+			    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				
+				if (translator.Assignable<UnityEngine.AnimationCurve>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					
+					UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+					int index = LuaAPI.xlua_tointeger(L, 2);
+					LuaAPI.lua_pushboolean(L, true);
+					translator.Push(L, gen_to_be_invoked[index]);
+					return 2;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+			
+            LuaAPI.lua_pushboolean(L, false);
+			return 1;
+        }
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Evaluate(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.Evaluate( _time );
+                        LuaAPI.lua_pushnumber(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AddKey(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
+                {
+                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
+                    float _value = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                        var gen_ret = gen_to_be_invoked.AddKey( _time, _value );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Keyframe>(L, 2)) 
+                {
+                    UnityEngine.Keyframe _key;translator.Get(L, 2, out _key);
+                    
+                        var gen_ret = gen_to_be_invoked.AddKey( _key );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AnimationCurve.AddKey!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_MoveKey(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _index = LuaAPI.xlua_tointeger(L, 2);
+                    UnityEngine.Keyframe _key;translator.Get(L, 3, out _key);
+                    
+                        var gen_ret = gen_to_be_invoked.MoveKey( _index, _key );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ClearKeys(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.ClearKeys(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RemoveKey(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _index = LuaAPI.xlua_tointeger(L, 2);
+                    
+                    gen_to_be_invoked.RemoveKey( _index );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHashCode(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetHashCode(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SmoothTangents(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    int _index = LuaAPI.xlua_tointeger(L, 2);
+                    float _weight = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                    gen_to_be_invoked.SmoothTangents( _index, _weight );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Constant_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    float _timeStart = (float)LuaAPI.lua_tonumber(L, 1);
+                    float _timeEnd = (float)LuaAPI.lua_tonumber(L, 2);
+                    float _value = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                        var gen_ret = UnityEngine.AnimationCurve.Constant( _timeStart, _timeEnd, _value );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Linear_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    float _timeStart = (float)LuaAPI.lua_tonumber(L, 1);
+                    float _valueStart = (float)LuaAPI.lua_tonumber(L, 2);
+                    float _timeEnd = (float)LuaAPI.lua_tonumber(L, 3);
+                    float _valueEnd = (float)LuaAPI.lua_tonumber(L, 4);
+                    
+                        var gen_ret = UnityEngine.AnimationCurve.Linear( _timeStart, _valueStart, _timeEnd, _valueEnd );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_EaseInOut_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    float _timeStart = (float)LuaAPI.lua_tonumber(L, 1);
+                    float _valueStart = (float)LuaAPI.lua_tonumber(L, 2);
+                    float _timeEnd = (float)LuaAPI.lua_tonumber(L, 3);
+                    float _valueEnd = (float)LuaAPI.lua_tonumber(L, 4);
+                    
+                        var gen_ret = UnityEngine.AnimationCurve.EaseInOut( _timeStart, _valueStart, _timeEnd, _valueEnd );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Equals(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 2)) 
+                {
+                    object _o = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _o );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.AnimationCurve>(L, 2)) 
+                {
+                    UnityEngine.AnimationCurve _other = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve));
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _other );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AnimationCurve.Equals!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_CopyFrom(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.AnimationCurve _other = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve));
+                    
+                    gen_to_be_invoked.CopyFrom( _other );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_keys(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.keys);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_length(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.length);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_preWrapMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.preWrapMode);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_postWrapMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.postWrapMode);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_keys(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.keys = (UnityEngine.Keyframe[])translator.GetObject(L, 2, typeof(UnityEngine.Keyframe[]));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_preWrapMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+                UnityEngine.WrapMode gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.preWrapMode = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_postWrapMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1);
+                UnityEngine.WrapMode gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.postWrapMode = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AnimationCurveWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f9c27f4acf5e5d64eaea5a300e702b7e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AnimatorStateInfoWrap.cs

@@ -0,0 +1,266 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineAnimatorStateInfoWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.AnimatorStateInfo);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 8, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsName", _m_IsName);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsTag", _m_IsTag);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "fullPathHash", _g_get_fullPathHash);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "shortNameHash", _g_get_shortNameHash);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalizedTime", _g_get_normalizedTime);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "speed", _g_get_speed);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "speedMultiplier", _g_get_speedMultiplier);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "tagHash", _g_get_tagHash);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "loop", _g_get_loop);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				
+				if (LuaAPI.lua_gettop(L) == 1)
+				{
+				    translator.Push(L, default(UnityEngine.AnimatorStateInfo));
+			        return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AnimatorStateInfo constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsName(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.IsName( _name );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.Update(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsTag(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    string _tag = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.IsTag( _tag );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.Update(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_fullPathHash(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.fullPathHash);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_shortNameHash(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.shortNameHash);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_normalizedTime(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalizedTime);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_length(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_speed(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.speed);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_speedMultiplier(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.speedMultiplier);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_tagHash(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.tagHash);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_loop(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loop);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AnimatorStateInfoWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e9170f7ca76be6b4e8d7e8bac42add53
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_AnimatorWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cfb8efe96091aba47a668aa9efb03d82
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ApplicationWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0e571910df9bc9a4bb4a8b164d76ff68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_BehaviourWrap.cs

@@ -0,0 +1,130 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineBehaviourWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.Behaviour);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 1);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isActiveAndEnabled", _g_get_isActiveAndEnabled);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.Behaviour();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Behaviour constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_enabled(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Behaviour gen_to_be_invoked = (UnityEngine.Behaviour)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enabled);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_isActiveAndEnabled(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Behaviour gen_to_be_invoked = (UnityEngine.Behaviour)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isActiveAndEnabled);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_enabled(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Behaviour gen_to_be_invoked = (UnityEngine.Behaviour)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_BehaviourWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 04911f55a3dc224469bedeccffc6f559
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_BoundsWrap.cs

@@ -0,0 +1,737 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineBoundsWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.Bounds);
+			Utils.BeginObjectRegister(type, L, translator, 1, 11, 5, 5);
+			Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta);
+            
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMinMax", _m_SetMinMax);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Encapsulate", _m_Encapsulate);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Expand", _m_Expand);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Intersects", _m_Intersects);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IntersectRay", _m_IntersectRay);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SqrDistance", _m_SqrDistance);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClosestPoint", _m_ClosestPoint);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "extents", _g_get_extents);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "min", _g_get_min);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "max", _g_get_max);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "extents", _s_set_extents);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "min", _s_set_min);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "max", _s_set_max);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable<UnityEngine.Vector3>(L, 2) && translator.Assignable<UnityEngine.Vector3>(L, 3))
+				{
+					UnityEngine.Vector3 _center;translator.Get(L, 2, out _center);
+					UnityEngine.Vector3 _size;translator.Get(L, 3, out _size);
+					
+					var gen_ret = new UnityEngine.Bounds(_center, _size);
+					translator.PushUnityEngineBounds(L, gen_ret);
+                    
+					return 1;
+				}
+				
+				if (LuaAPI.lua_gettop(L) == 1)
+				{
+				    translator.PushUnityEngineBounds(L, default(UnityEngine.Bounds));
+			        return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __EqMeta(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+			
+				if (translator.Assignable<UnityEngine.Bounds>(L, 1) && translator.Assignable<UnityEngine.Bounds>(L, 2))
+				{
+					UnityEngine.Bounds leftside;translator.Get(L, 1, out leftside);
+					UnityEngine.Bounds rightside;translator.Get(L, 2, out rightside);
+					
+					LuaAPI.lua_pushboolean(L, leftside == rightside);
+					
+					return 1;
+				}
+            
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Bounds!");
+            
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHashCode(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetHashCode(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Equals(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 2)) 
+                {
+                    object _other = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _other );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Bounds>(L, 2)) 
+                {
+                    UnityEngine.Bounds _other;translator.Get(L, 2, out _other);
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _other );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.Equals!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SetMinMax(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    UnityEngine.Vector3 _min;translator.Get(L, 2, out _min);
+                    UnityEngine.Vector3 _max;translator.Get(L, 3, out _max);
+                    
+                    gen_to_be_invoked.SetMinMax( _min, _max );
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Encapsulate(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector3>(L, 2)) 
+                {
+                    UnityEngine.Vector3 _point;translator.Get(L, 2, out _point);
+                    
+                    gen_to_be_invoked.Encapsulate( _point );
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Bounds>(L, 2)) 
+                {
+                    UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds);
+                    
+                    gen_to_be_invoked.Encapsulate( _bounds );
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.Encapsulate!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Expand(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
+                {
+                    float _amount = (float)LuaAPI.lua_tonumber(L, 2);
+                    
+                    gen_to_be_invoked.Expand( _amount );
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector3>(L, 2)) 
+                {
+                    UnityEngine.Vector3 _amount;translator.Get(L, 2, out _amount);
+                    
+                    gen_to_be_invoked.Expand( _amount );
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.Expand!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Intersects(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds);
+                    
+                        var gen_ret = gen_to_be_invoked.Intersects( _bounds );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IntersectRay(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Ray>(L, 2)) 
+                {
+                    UnityEngine.Ray _ray;translator.Get(L, 2, out _ray);
+                    
+                        var gen_ret = gen_to_be_invoked.IntersectRay( _ray );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Ray>(L, 2)) 
+                {
+                    UnityEngine.Ray _ray;translator.Get(L, 2, out _ray);
+                    float _distance;
+                    
+                        var gen_ret = gen_to_be_invoked.IntersectRay( _ray, out _distance );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    LuaAPI.lua_pushnumber(L, _distance);
+                        
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 2;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.IntersectRay!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToString(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1) 
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.ToString(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ToString( _format );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.IFormatProvider>(L, 3)) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider));
+                    
+                        var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.ToString!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Contains(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    UnityEngine.Vector3 _point;translator.Get(L, 2, out _point);
+                    
+                        var gen_ret = gen_to_be_invoked.Contains( _point );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SqrDistance(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    UnityEngine.Vector3 _point;translator.Get(L, 2, out _point);
+                    
+                        var gen_ret = gen_to_be_invoked.SqrDistance( _point );
+                        LuaAPI.lua_pushnumber(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ClosestPoint(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    UnityEngine.Vector3 _point;translator.Get(L, 2, out _point);
+                    
+                        var gen_ret = gen_to_be_invoked.ClosestPoint( _point );
+                        translator.PushUnityEngineVector3(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_center(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.center);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_size(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.size);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_extents(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.extents);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_min(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.min);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_max(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.max);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_center(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.center = gen_value;
+            
+                translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_size(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.size = gen_value;
+            
+                translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_extents(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.extents = gen_value;
+            
+                translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_min(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.min = gen_value;
+            
+                translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_max(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.max = gen_value;
+            
+                translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_BoundsWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dcf06f8f95db25342b2b8007faf1dcd4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_BoxColliderWrap.cs

@@ -0,0 +1,148 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineBoxColliderWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.BoxCollider);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.BoxCollider();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.BoxCollider constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_center(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.center);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_size(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineVector3(L, gen_to_be_invoked.size);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_center(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.center = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_size(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1);
+                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.size = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_BoxColliderWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5eb11d8a79cc05045bc4005b943ad095
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_CameraWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9c45759b8423f704097e3e747e627c86
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_CanvasGroupWrap.cs

@@ -0,0 +1,270 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+using DG.Tweening;
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineCanvasGroupWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.CanvasGroup);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 4, 4);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsRaycastLocationValid", _m_IsRaycastLocationValid);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "alpha", _g_get_alpha);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "interactable", _g_get_interactable);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "blocksRaycasts", _g_get_blocksRaycasts);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreParentGroups", _g_get_ignoreParentGroups);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "alpha", _s_set_alpha);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "interactable", _s_set_interactable);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "blocksRaycasts", _s_set_blocksRaycasts);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreParentGroups", _s_set_ignoreParentGroups);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.CanvasGroup();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.CanvasGroup constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsRaycastLocationValid(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.Vector2 _sp;translator.Get(L, 2, out _sp);
+                    UnityEngine.Camera _eventCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera));
+                    
+                        var gen_ret = gen_to_be_invoked.IsRaycastLocationValid( _sp, _eventCamera );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_DOFade(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    float _endValue = (float)LuaAPI.lua_tonumber(L, 2);
+                    float _duration = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                        var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_alpha(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.alpha);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_interactable(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.interactable);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_blocksRaycasts(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.blocksRaycasts);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_ignoreParentGroups(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreParentGroups);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_alpha(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.alpha = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_interactable(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.interactable = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_blocksRaycasts(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.blocksRaycasts = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_ignoreParentGroups(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.ignoreParentGroups = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_CanvasGroupWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9b128891ce9e38b4aa98359a9a8e8aa6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_CanvasWrap.cs

@@ -0,0 +1,811 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineCanvasWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.Canvas);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 22, 16);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderMode", _g_get_renderMode);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isRootCanvas", _g_get_isRootCanvas);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelRect", _g_get_pixelRect);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "scaleFactor", _g_get_scaleFactor);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "referencePixelsPerUnit", _g_get_referencePixelsPerUnit);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "overridePixelPerfect", _g_get_overridePixelPerfect);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexColorAlwaysGammaSpace", _g_get_vertexColorAlwaysGammaSpace);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelPerfect", _g_get_pixelPerfect);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "planeDistance", _g_get_planeDistance);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderOrder", _g_get_renderOrder);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "overrideSorting", _g_get_overrideSorting);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingOrder", _g_get_sortingOrder);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetDisplay", _g_get_targetDisplay);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingLayerID", _g_get_sortingLayerID);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "cachedSortingLayerValue", _g_get_cachedSortingLayerValue);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "additionalShaderChannels", _g_get_additionalShaderChannels);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingLayerName", _g_get_sortingLayerName);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rootCanvas", _g_get_rootCanvas);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderingDisplaySize", _g_get_renderingDisplaySize);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateRectTransformForStandalone", _g_get_updateRectTransformForStandalone);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "worldCamera", _g_get_worldCamera);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalizedSortingGridSize", _g_get_normalizedSortingGridSize);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderMode", _s_set_renderMode);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "scaleFactor", _s_set_scaleFactor);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "referencePixelsPerUnit", _s_set_referencePixelsPerUnit);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "overridePixelPerfect", _s_set_overridePixelPerfect);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertexColorAlwaysGammaSpace", _s_set_vertexColorAlwaysGammaSpace);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "pixelPerfect", _s_set_pixelPerfect);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "planeDistance", _s_set_planeDistance);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "overrideSorting", _s_set_overrideSorting);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingOrder", _s_set_sortingOrder);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetDisplay", _s_set_targetDisplay);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingLayerID", _s_set_sortingLayerID);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "additionalShaderChannels", _s_set_additionalShaderChannels);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingLayerName", _s_set_sortingLayerName);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "updateRectTransformForStandalone", _s_set_updateRectTransformForStandalone);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "worldCamera", _s_set_worldCamera);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalizedSortingGridSize", _s_set_normalizedSortingGridSize);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDefaultCanvasMaterial", _m_GetDefaultCanvasMaterial_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetETC1SupportedCanvasMaterial", _m_GetETC1SupportedCanvasMaterial_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ForceUpdateCanvases", _m_ForceUpdateCanvases_xlua_st_);
+            
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "preWillRenderCanvases", _e_preWillRenderCanvases);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "willRenderCanvases", _e_willRenderCanvases);
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.Canvas();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Canvas constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetDefaultCanvasMaterial_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    
+                        var gen_ret = UnityEngine.Canvas.GetDefaultCanvasMaterial(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetETC1SupportedCanvasMaterial_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    
+                        var gen_ret = UnityEngine.Canvas.GetETC1SupportedCanvasMaterial(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ForceUpdateCanvases_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                    UnityEngine.Canvas.ForceUpdateCanvases(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_renderMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.renderMode);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_isRootCanvas(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isRootCanvas);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_pixelRect(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.pixelRect);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_scaleFactor(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scaleFactor);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_referencePixelsPerUnit(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.referencePixelsPerUnit);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_overridePixelPerfect(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.overridePixelPerfect);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_vertexColorAlwaysGammaSpace(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.vertexColorAlwaysGammaSpace);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_pixelPerfect(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.pixelPerfect);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_planeDistance(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.planeDistance);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_renderOrder(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.renderOrder);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_overrideSorting(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.overrideSorting);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_sortingOrder(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingOrder);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_targetDisplay(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.targetDisplay);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_sortingLayerID(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingLayerID);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_cachedSortingLayerValue(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cachedSortingLayerValue);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_additionalShaderChannels(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.additionalShaderChannels);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_sortingLayerName(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.sortingLayerName);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_rootCanvas(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.rootCanvas);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_renderingDisplaySize(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineVector2(L, gen_to_be_invoked.renderingDisplaySize);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_updateRectTransformForStandalone(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.updateRectTransformForStandalone);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_worldCamera(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.worldCamera);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_normalizedSortingGridSize(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalizedSortingGridSize);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_renderMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                UnityEngine.RenderMode gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.renderMode = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_scaleFactor(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.scaleFactor = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_referencePixelsPerUnit(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.referencePixelsPerUnit = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_overridePixelPerfect(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.overridePixelPerfect = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_vertexColorAlwaysGammaSpace(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.vertexColorAlwaysGammaSpace = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_pixelPerfect(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.pixelPerfect = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_planeDistance(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.planeDistance = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_overrideSorting(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.overrideSorting = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_sortingOrder(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.sortingOrder = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_targetDisplay(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.targetDisplay = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_sortingLayerID(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.sortingLayerID = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_additionalShaderChannels(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                UnityEngine.AdditionalCanvasShaderChannels gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.additionalShaderChannels = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_sortingLayerName(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.sortingLayerName = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_updateRectTransformForStandalone(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                UnityEngine.StandaloneRenderResize gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.updateRectTransformForStandalone = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_worldCamera(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.worldCamera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_normalizedSortingGridSize(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.normalizedSortingGridSize = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _e_preWillRenderCanvases(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+                UnityEngine.Canvas.WillRenderCanvases gen_delegate = translator.GetDelegate<UnityEngine.Canvas.WillRenderCanvases>(L, 2);
+                if (gen_delegate == null) {
+                    return LuaAPI.luaL_error(L, "#2 need UnityEngine.Canvas.WillRenderCanvases!");
+                }
+                
+				
+				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) {
+					UnityEngine.Canvas.preWillRenderCanvases += gen_delegate;
+					return 0;
+				} 
+				
+				
+				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) {
+					UnityEngine.Canvas.preWillRenderCanvases -= gen_delegate;
+					return 0;
+				} 
+				
+			} catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+			return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Canvas.preWillRenderCanvases!");
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _e_willRenderCanvases(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+                UnityEngine.Canvas.WillRenderCanvases gen_delegate = translator.GetDelegate<UnityEngine.Canvas.WillRenderCanvases>(L, 2);
+                if (gen_delegate == null) {
+                    return LuaAPI.luaL_error(L, "#2 need UnityEngine.Canvas.WillRenderCanvases!");
+                }
+                
+				
+				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) {
+					UnityEngine.Canvas.willRenderCanvases += gen_delegate;
+					return 0;
+				} 
+				
+				
+				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) {
+					UnityEngine.Canvas.willRenderCanvases -= gen_delegate;
+					return 0;
+				} 
+				
+			} catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+			return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Canvas.willRenderCanvases!");
+        }
+        
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_CanvasWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e49d3c1318472f4092031dbf4af0072
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ColliderWrap.cs

@@ -0,0 +1,535 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineColliderWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.Collider);
+			Utils.BeginObjectRegister(type, L, translator, 0, 3, 13, 10);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClosestPoint", _m_ClosestPoint);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Raycast", _m_Raycast);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClosestPointOnBounds", _m_ClosestPointOnBounds);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attachedRigidbody", _g_get_attachedRigidbody);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attachedArticulationBody", _g_get_attachedArticulationBody);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isTrigger", _g_get_isTrigger);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "contactOffset", _g_get_contactOffset);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounds", _g_get_bounds);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasModifiableContacts", _g_get_hasModifiableContacts);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "providesContacts", _g_get_providesContacts);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "layerOverridePriority", _g_get_layerOverridePriority);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "excludeLayers", _g_get_excludeLayers);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "includeLayers", _g_get_includeLayers);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "sharedMaterial", _g_get_sharedMaterial);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "material", _g_get_material);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isTrigger", _s_set_isTrigger);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "contactOffset", _s_set_contactOffset);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasModifiableContacts", _s_set_hasModifiableContacts);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "providesContacts", _s_set_providesContacts);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "layerOverridePriority", _s_set_layerOverridePriority);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "excludeLayers", _s_set_excludeLayers);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "includeLayers", _s_set_includeLayers);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "sharedMaterial", _s_set_sharedMaterial);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "material", _s_set_material);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.Collider();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Collider constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ClosestPoint(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.Vector3 _position;translator.Get(L, 2, out _position);
+                    
+                        var gen_ret = gen_to_be_invoked.ClosestPoint( _position );
+                        translator.PushUnityEngineVector3(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Raycast(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.Ray _ray;translator.Get(L, 2, out _ray);
+                    UnityEngine.RaycastHit _hitInfo;
+                    float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                        var gen_ret = gen_to_be_invoked.Raycast( _ray, out _hitInfo, _maxDistance );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    translator.Push(L, _hitInfo);
+                        
+                    
+                    
+                    
+                    return 2;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ClosestPointOnBounds(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.Vector3 _position;translator.Get(L, 2, out _position);
+                    
+                        var gen_ret = gen_to_be_invoked.ClosestPointOnBounds( _position );
+                        translator.PushUnityEngineVector3(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_enabled(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enabled);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_attachedRigidbody(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.attachedRigidbody);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_attachedArticulationBody(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.attachedArticulationBody);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_isTrigger(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isTrigger);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_contactOffset(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.contactOffset);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_bounds(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                translator.PushUnityEngineBounds(L, gen_to_be_invoked.bounds);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_hasModifiableContacts(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasModifiableContacts);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_providesContacts(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.providesContacts);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_layerOverridePriority(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layerOverridePriority);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_excludeLayers(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.excludeLayers);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_includeLayers(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.includeLayers);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_sharedMaterial(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.sharedMaterial);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_material(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.material);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_enabled(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_isTrigger(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.isTrigger = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_contactOffset(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.contactOffset = (float)LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_hasModifiableContacts(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.hasModifiableContacts = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_providesContacts(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.providesContacts = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_layerOverridePriority(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.layerOverridePriority = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_excludeLayers(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                UnityEngine.LayerMask gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.excludeLayers = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_includeLayers(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                UnityEngine.LayerMask gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.includeLayers = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_sharedMaterial(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.sharedMaterial = (UnityEngine.PhysicMaterial)translator.GetObject(L, 2, typeof(UnityEngine.PhysicMaterial));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_material(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Collider gen_to_be_invoked = (UnityEngine.Collider)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.material = (UnityEngine.PhysicMaterial)translator.GetObject(L, 2, typeof(UnityEngine.PhysicMaterial));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ColliderWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ea725c42ca7e9a843bf45e16cc5f3c3a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ColorUtilityWrap.cs

@@ -0,0 +1,171 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineColorUtilityWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.ColorUtility);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "TryParseHtmlString", _m_TryParseHtmlString_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ToHtmlStringRGB", _m_ToHtmlStringRGB_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ToHtmlStringRGBA", _m_ToHtmlStringRGBA_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.ColorUtility();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ColorUtility constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_TryParseHtmlString_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _htmlString = LuaAPI.lua_tostring(L, 1);
+                    UnityEngine.Color _color;
+                    
+                        var gen_ret = UnityEngine.ColorUtility.TryParseHtmlString( _htmlString, out _color );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    translator.PushUnityEngineColor(L, _color);
+                        
+                    
+                    
+                    
+                    return 2;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToHtmlStringRGB_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    UnityEngine.Color _color;translator.Get(L, 1, out _color);
+                    
+                        var gen_ret = UnityEngine.ColorUtility.ToHtmlStringRGB( _color );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToHtmlStringRGBA_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    UnityEngine.Color _color;translator.Get(L, 1, out _color);
+                    
+                        var gen_ret = UnityEngine.ColorUtility.ToHtmlStringRGBA( _color );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ColorUtilityWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 05362012022df3641acb8213aefcdc5b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ColorWrap.cs

@@ -0,0 +1,934 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineColorWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.Color);
+			Utils.BeginObjectRegister(type, L, translator, 5, 3, 8, 4);
+			Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta);
+            Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta);
+            Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__mul", __MulMeta);
+            Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__div", __DivMeta);
+            Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta);
+            
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "grayscale", _g_get_grayscale);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "linear", _g_get_linear);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "gamma", _g_get_gamma);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxColorComponent", _g_get_maxColorComponent);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "r", _g_get_r);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "g", _g_get_g);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "b", _g_get_b);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "a", _g_get_a);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "r", _s_set_r);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "g", _s_set_g);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "b", _s_set_b);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "a", _s_set_a);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 5, 11, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "Lerp", _m_Lerp_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpUnclamped", _m_LerpUnclamped_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "RGBToHSV", _m_RGBToHSV_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "HSVToRGB", _m_HSVToRGB_xlua_st_);
+            
+			
+            
+			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "red", _g_get_red);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "green", _g_get_green);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "blue", _g_get_blue);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "white", _g_get_white);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "black", _g_get_black);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "yellow", _g_get_yellow);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "cyan", _g_get_cyan);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "magenta", _g_get_magenta);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "gray", _g_get_gray);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "grey", _g_get_grey);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "clear", _g_get_clear);
+            
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5))
+				{
+					float _r = (float)LuaAPI.lua_tonumber(L, 2);
+					float _g = (float)LuaAPI.lua_tonumber(L, 3);
+					float _b = (float)LuaAPI.lua_tonumber(L, 4);
+					float _a = (float)LuaAPI.lua_tonumber(L, 5);
+					
+					var gen_ret = new UnityEngine.Color(_r, _g, _b, _a);
+					translator.PushUnityEngineColor(L, gen_ret);
+                    
+					return 1;
+				}
+				if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4))
+				{
+					float _r = (float)LuaAPI.lua_tonumber(L, 2);
+					float _g = (float)LuaAPI.lua_tonumber(L, 3);
+					float _b = (float)LuaAPI.lua_tonumber(L, 4);
+					
+					var gen_ret = new UnityEngine.Color(_r, _g, _b);
+					translator.PushUnityEngineColor(L, gen_ret);
+                    
+					return 1;
+				}
+				
+				if (LuaAPI.lua_gettop(L) == 1)
+				{
+				    translator.PushUnityEngineColor(L, default(UnityEngine.Color));
+			        return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Color constructor!");
+            
+        }
+        
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        public static int __CSIndexer(RealStatePtr L)
+        {
+			try {
+			    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					
+					UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+					int index = LuaAPI.xlua_tointeger(L, 2);
+					LuaAPI.lua_pushboolean(L, true);
+					LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]);
+					return 2;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+			
+            LuaAPI.lua_pushboolean(L, false);
+			return 1;
+        }
+		
+        
+		
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        public static int __NewIndexer(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+			try {
+				
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3))
+				{
+					
+					UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+					int key = LuaAPI.xlua_tointeger(L, 2);
+					gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3);
+					LuaAPI.lua_pushboolean(L, true);
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+			
+			LuaAPI.lua_pushboolean(L, false);
+            return 1;
+        }
+		
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __AddMeta(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+			
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && translator.Assignable<UnityEngine.Color>(L, 2))
+				{
+					UnityEngine.Color leftside;translator.Get(L, 1, out leftside);
+					UnityEngine.Color rightside;translator.Get(L, 2, out rightside);
+					
+					translator.PushUnityEngineColor(L, leftside + rightside);
+					
+					return 1;
+				}
+            
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need UnityEngine.Color!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __SubMeta(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+			
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && translator.Assignable<UnityEngine.Color>(L, 2))
+				{
+					UnityEngine.Color leftside;translator.Get(L, 1, out leftside);
+					UnityEngine.Color rightside;translator.Get(L, 2, out rightside);
+					
+					translator.PushUnityEngineColor(L, leftside - rightside);
+					
+					return 1;
+				}
+            
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need UnityEngine.Color!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __MulMeta(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+			
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && translator.Assignable<UnityEngine.Color>(L, 2))
+				{
+					UnityEngine.Color leftside;translator.Get(L, 1, out leftside);
+					UnityEngine.Color rightside;translator.Get(L, 2, out rightside);
+					
+					translator.PushUnityEngineColor(L, leftside * rightside);
+					
+					return 1;
+				}
+            
+			
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					UnityEngine.Color leftside;translator.Get(L, 1, out leftside);
+					float rightside = (float)LuaAPI.lua_tonumber(L, 2);
+					
+					translator.PushUnityEngineColor(L, leftside * rightside);
+					
+					return 1;
+				}
+            
+			
+				if (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) && translator.Assignable<UnityEngine.Color>(L, 2))
+				{
+					float leftside = (float)LuaAPI.lua_tonumber(L, 1);
+					UnityEngine.Color rightside;translator.Get(L, 2, out rightside);
+					
+					translator.PushUnityEngineColor(L, leftside * rightside);
+					
+					return 1;
+				}
+            
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to right hand of * operator, need UnityEngine.Color!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __DivMeta(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+			
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
+				{
+					UnityEngine.Color leftside;translator.Get(L, 1, out leftside);
+					float rightside = (float)LuaAPI.lua_tonumber(L, 2);
+					
+					translator.PushUnityEngineColor(L, leftside / rightside);
+					
+					return 1;
+				}
+            
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to right hand of / operator, need UnityEngine.Color!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __EqMeta(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+			
+				if (translator.Assignable<UnityEngine.Color>(L, 1) && translator.Assignable<UnityEngine.Color>(L, 2))
+				{
+					UnityEngine.Color leftside;translator.Get(L, 1, out leftside);
+					UnityEngine.Color rightside;translator.Get(L, 2, out rightside);
+					
+					LuaAPI.lua_pushboolean(L, leftside == rightside);
+					
+					return 1;
+				}
+            
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Color!");
+            
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToString(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1) 
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.ToString(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = gen_to_be_invoked.ToString( _format );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.IFormatProvider>(L, 3)) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider));
+                    
+                        var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Color.ToString!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetHashCode(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetHashCode(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Equals(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 2)) 
+                {
+                    object _other = translator.GetObject(L, 2, typeof(object));
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _other );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Color>(L, 2)) 
+                {
+                    UnityEngine.Color _other;translator.Get(L, 2, out _other);
+                    
+                        var gen_ret = gen_to_be_invoked.Equals( _other );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                        translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Color.Equals!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Lerp_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    UnityEngine.Color _a;translator.Get(L, 1, out _a);
+                    UnityEngine.Color _b;translator.Get(L, 2, out _b);
+                    float _t = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                        var gen_ret = UnityEngine.Color.Lerp( _a, _b, _t );
+                        translator.PushUnityEngineColor(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LerpUnclamped_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    UnityEngine.Color _a;translator.Get(L, 1, out _a);
+                    UnityEngine.Color _b;translator.Get(L, 2, out _b);
+                    float _t = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                        var gen_ret = UnityEngine.Color.LerpUnclamped( _a, _b, _t );
+                        translator.PushUnityEngineColor(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RGBToHSV_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    UnityEngine.Color _rgbColor;translator.Get(L, 1, out _rgbColor);
+                    float _H;
+                    float _S;
+                    float _V;
+                    
+                    UnityEngine.Color.RGBToHSV( _rgbColor, out _H, out _S, out _V );
+                    LuaAPI.lua_pushnumber(L, _H);
+                        
+                    LuaAPI.lua_pushnumber(L, _S);
+                        
+                    LuaAPI.lua_pushnumber(L, _V);
+                        
+                    
+                    
+                    
+                    return 3;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_HSVToRGB_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
+                {
+                    float _H = (float)LuaAPI.lua_tonumber(L, 1);
+                    float _S = (float)LuaAPI.lua_tonumber(L, 2);
+                    float _V = (float)LuaAPI.lua_tonumber(L, 3);
+                    
+                        var gen_ret = UnityEngine.Color.HSVToRGB( _H, _S, _V );
+                        translator.PushUnityEngineColor(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) 
+                {
+                    float _H = (float)LuaAPI.lua_tonumber(L, 1);
+                    float _S = (float)LuaAPI.lua_tonumber(L, 2);
+                    float _V = (float)LuaAPI.lua_tonumber(L, 3);
+                    bool _hdr = LuaAPI.lua_toboolean(L, 4);
+                    
+                        var gen_ret = UnityEngine.Color.HSVToRGB( _H, _S, _V, _hdr );
+                        translator.PushUnityEngineColor(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Color.HSVToRGB!");
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_red(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.red);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_green(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.green);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_blue(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.blue);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_white(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.white);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_black(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.black);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_yellow(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.yellow);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_cyan(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.cyan);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_magenta(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.magenta);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_gray(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.gray);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_grey(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.grey);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_clear(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushUnityEngineColor(L, UnityEngine.Color.clear);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_grayscale(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.grayscale);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_linear(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.PushUnityEngineColor(L, gen_to_be_invoked.linear);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_gamma(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                translator.PushUnityEngineColor(L, gen_to_be_invoked.gamma);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_maxColorComponent(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxColorComponent);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_r(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.r);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_g(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.g);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_b(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.b);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_a(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.a);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_r(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                gen_to_be_invoked.r = (float)LuaAPI.lua_tonumber(L, 2);
+            
+                translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_g(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                gen_to_be_invoked.g = (float)LuaAPI.lua_tonumber(L, 2);
+            
+                translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_b(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                gen_to_be_invoked.b = (float)LuaAPI.lua_tonumber(L, 2);
+            
+                translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_a(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked);
+                gen_to_be_invoked.a = (float)LuaAPI.lua_tonumber(L, 2);
+            
+                translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ColorWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d26bfff43f639524e85c6031075768b7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_ComponentWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7adf46659bf24af4b8c59eee7fc0edd6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_DebugWrap.cs

@@ -0,0 +1,912 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineDebugWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.Debug);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 17, 4, 2);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawLine", _m_DrawLine_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawRay", _m_DrawRay_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "Break", _m_Break_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "DebugBreak", _m_DebugBreak_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "Log", _m_Log_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogFormat", _m_LogFormat_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogError", _m_LogError_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogErrorFormat", _m_LogErrorFormat_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearDeveloperConsole", _m_ClearDeveloperConsole_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogException", _m_LogException_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogWarning", _m_LogWarning_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogWarningFormat", _m_LogWarningFormat_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "Assert", _m_Assert_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "AssertFormat", _m_AssertFormat_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogAssertion", _m_LogAssertion_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogAssertionFormat", _m_LogAssertionFormat_xlua_st_);
+            
+			
+            
+			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "unityLogger", _g_get_unityLogger);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "developerConsoleEnabled", _g_get_developerConsoleEnabled);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "developerConsoleVisible", _g_get_developerConsoleVisible);
+            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isDebugBuild", _g_get_isDebugBuild);
+            
+			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "developerConsoleEnabled", _s_set_developerConsoleEnabled);
+            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "developerConsoleVisible", _s_set_developerConsoleVisible);
+            
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.Debug();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_DrawLine_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _end;translator.Get(L, 2, out _end);
+                    
+                    UnityEngine.Debug.DrawLine( _start, _end );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 3&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Color>(L, 3)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _end;translator.Get(L, 2, out _end);
+                    UnityEngine.Color _color;translator.Get(L, 3, out _color);
+                    
+                    UnityEngine.Debug.DrawLine( _start, _end, _color );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 4&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Color>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _end;translator.Get(L, 2, out _end);
+                    UnityEngine.Color _color;translator.Get(L, 3, out _color);
+                    float _duration = (float)LuaAPI.lua_tonumber(L, 4);
+                    
+                    UnityEngine.Debug.DrawLine( _start, _end, _color, _duration );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 5&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Color>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _end;translator.Get(L, 2, out _end);
+                    UnityEngine.Color _color;translator.Get(L, 3, out _color);
+                    float _duration = (float)LuaAPI.lua_tonumber(L, 4);
+                    bool _depthTest = LuaAPI.lua_toboolean(L, 5);
+                    
+                    UnityEngine.Debug.DrawLine( _start, _end, _color, _duration, _depthTest );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.DrawLine!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_DrawRay_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir);
+                    
+                    UnityEngine.Debug.DrawRay( _start, _dir );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 3&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Color>(L, 3)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir);
+                    UnityEngine.Color _color;translator.Get(L, 3, out _color);
+                    
+                    UnityEngine.Debug.DrawRay( _start, _dir, _color );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 4&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Color>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir);
+                    UnityEngine.Color _color;translator.Get(L, 3, out _color);
+                    float _duration = (float)LuaAPI.lua_tonumber(L, 4);
+                    
+                    UnityEngine.Debug.DrawRay( _start, _dir, _color, _duration );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 5&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Color>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) 
+                {
+                    UnityEngine.Vector3 _start;translator.Get(L, 1, out _start);
+                    UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir);
+                    UnityEngine.Color _color;translator.Get(L, 3, out _color);
+                    float _duration = (float)LuaAPI.lua_tonumber(L, 4);
+                    bool _depthTest = LuaAPI.lua_toboolean(L, 5);
+                    
+                    UnityEngine.Debug.DrawRay( _start, _dir, _color, _duration, _depthTest );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.DrawRay!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Break_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                    UnityEngine.Debug.Break(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_DebugBreak_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                    UnityEngine.Debug.DebugBreak(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Log_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& translator.Assignable<object>(L, 1)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    
+                    UnityEngine.Debug.Log( _message );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 1)&& translator.Assignable<UnityEngine.Object>(L, 2)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.Log( _message, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.Log!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogFormat_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count >= 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable<object>(L, 2))) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 1);
+                    object[] _args = translator.GetParams<object>(L, 2);
+                    
+                    UnityEngine.Debug.LogFormat( _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count >= 2&& translator.Assignable<UnityEngine.Object>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable<object>(L, 3))) 
+                {
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object));
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    object[] _args = translator.GetParams<object>(L, 3);
+                    
+                    UnityEngine.Debug.LogFormat( _context, _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count >= 4&& translator.Assignable<UnityEngine.LogType>(L, 1)&& translator.Assignable<UnityEngine.LogOption>(L, 2)&& translator.Assignable<UnityEngine.Object>(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 5) || translator.Assignable<object>(L, 5))) 
+                {
+                    UnityEngine.LogType _logType;translator.Get(L, 1, out _logType);
+                    UnityEngine.LogOption _logOptions;translator.Get(L, 2, out _logOptions);
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object));
+                    string _format = LuaAPI.lua_tostring(L, 4);
+                    object[] _args = translator.GetParams<object>(L, 5);
+                    
+                    UnityEngine.Debug.LogFormat( _logType, _logOptions, _context, _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogFormat!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogError_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& translator.Assignable<object>(L, 1)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    
+                    UnityEngine.Debug.LogError( _message );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 1)&& translator.Assignable<UnityEngine.Object>(L, 2)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.LogError( _message, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogError!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogErrorFormat_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count >= 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable<object>(L, 2))) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 1);
+                    object[] _args = translator.GetParams<object>(L, 2);
+                    
+                    UnityEngine.Debug.LogErrorFormat( _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count >= 2&& translator.Assignable<UnityEngine.Object>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable<object>(L, 3))) 
+                {
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object));
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    object[] _args = translator.GetParams<object>(L, 3);
+                    
+                    UnityEngine.Debug.LogErrorFormat( _context, _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogErrorFormat!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ClearDeveloperConsole_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                    UnityEngine.Debug.ClearDeveloperConsole(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogException_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& translator.Assignable<System.Exception>(L, 1)) 
+                {
+                    System.Exception _exception = (System.Exception)translator.GetObject(L, 1, typeof(System.Exception));
+                    
+                    UnityEngine.Debug.LogException( _exception );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& translator.Assignable<System.Exception>(L, 1)&& translator.Assignable<UnityEngine.Object>(L, 2)) 
+                {
+                    System.Exception _exception = (System.Exception)translator.GetObject(L, 1, typeof(System.Exception));
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.LogException( _exception, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogException!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogWarning_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& translator.Assignable<object>(L, 1)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    
+                    UnityEngine.Debug.LogWarning( _message );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 1)&& translator.Assignable<UnityEngine.Object>(L, 2)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.LogWarning( _message, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogWarning!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogWarningFormat_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count >= 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable<object>(L, 2))) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 1);
+                    object[] _args = translator.GetParams<object>(L, 2);
+                    
+                    UnityEngine.Debug.LogWarningFormat( _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count >= 2&& translator.Assignable<UnityEngine.Object>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable<object>(L, 3))) 
+                {
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object));
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    object[] _args = translator.GetParams<object>(L, 3);
+                    
+                    UnityEngine.Debug.LogWarningFormat( _context, _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogWarningFormat!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Assert_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    
+                    UnityEngine.Debug.Assert( _condition );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable<UnityEngine.Object>(L, 2)) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.Assert( _condition, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable<object>(L, 2)) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    object _message = translator.GetObject(L, 2, typeof(object));
+                    
+                    UnityEngine.Debug.Assert( _condition, _message );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    string _message = LuaAPI.lua_tostring(L, 2);
+                    
+                    UnityEngine.Debug.Assert( _condition, _message );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable<object>(L, 2)&& translator.Assignable<UnityEngine.Object>(L, 3)) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    object _message = translator.GetObject(L, 2, typeof(object));
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.Assert( _condition, _message, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable<UnityEngine.Object>(L, 3)) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    string _message = LuaAPI.lua_tostring(L, 2);
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.Assert( _condition, _message, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.Assert!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AssertFormat_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count >= 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable<object>(L, 3))) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    object[] _args = translator.GetParams<object>(L, 3);
+                    
+                    UnityEngine.Debug.AssertFormat( _condition, _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count >= 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable<UnityEngine.Object>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 4) || translator.Assignable<object>(L, 4))) 
+                {
+                    bool _condition = LuaAPI.lua_toboolean(L, 1);
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object));
+                    string _format = LuaAPI.lua_tostring(L, 3);
+                    object[] _args = translator.GetParams<object>(L, 4);
+                    
+                    UnityEngine.Debug.AssertFormat( _condition, _context, _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.AssertFormat!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogAssertion_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& translator.Assignable<object>(L, 1)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    
+                    UnityEngine.Debug.LogAssertion( _message );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& translator.Assignable<object>(L, 1)&& translator.Assignable<UnityEngine.Object>(L, 2)) 
+                {
+                    object _message = translator.GetObject(L, 1, typeof(object));
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object));
+                    
+                    UnityEngine.Debug.LogAssertion( _message, _context );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogAssertion!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_LogAssertionFormat_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count >= 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable<object>(L, 2))) 
+                {
+                    string _format = LuaAPI.lua_tostring(L, 1);
+                    object[] _args = translator.GetParams<object>(L, 2);
+                    
+                    UnityEngine.Debug.LogAssertionFormat( _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count >= 2&& translator.Assignable<UnityEngine.Object>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable<object>(L, 3))) 
+                {
+                    UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object));
+                    string _format = LuaAPI.lua_tostring(L, 2);
+                    object[] _args = translator.GetParams<object>(L, 3);
+                    
+                    UnityEngine.Debug.LogAssertionFormat( _context, _format, _args );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogAssertionFormat!");
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_unityLogger(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			    translator.PushAny(L, UnityEngine.Debug.unityLogger);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_developerConsoleEnabled(RealStatePtr L)
+        {
+		    try {
+            
+			    LuaAPI.lua_pushboolean(L, UnityEngine.Debug.developerConsoleEnabled);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_developerConsoleVisible(RealStatePtr L)
+        {
+		    try {
+            
+			    LuaAPI.lua_pushboolean(L, UnityEngine.Debug.developerConsoleVisible);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_isDebugBuild(RealStatePtr L)
+        {
+		    try {
+            
+			    LuaAPI.lua_pushboolean(L, UnityEngine.Debug.isDebugBuild);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_developerConsoleEnabled(RealStatePtr L)
+        {
+		    try {
+                
+			    UnityEngine.Debug.developerConsoleEnabled = LuaAPI.lua_toboolean(L, 1);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_developerConsoleVisible(RealStatePtr L)
+        {
+		    try {
+                
+			    UnityEngine.Debug.developerConsoleVisible = LuaAPI.lua_toboolean(L, 1);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_DebugWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e2bdcf501edb1e749a5dd20ce357afc4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_EventSystems_BaseEventDataWrap.cs

@@ -0,0 +1,131 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineEventSystemsBaseEventDataWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.EventSystems.BaseEventData);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 1);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "currentInputModule", _g_get_currentInputModule);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedObject", _g_get_selectedObject);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectedObject", _s_set_selectedObject);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable<UnityEngine.EventSystems.EventSystem>(L, 2))
+				{
+					UnityEngine.EventSystems.EventSystem _eventSystem = (UnityEngine.EventSystems.EventSystem)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.EventSystem));
+					
+					var gen_ret = new UnityEngine.EventSystems.BaseEventData(_eventSystem);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.EventSystems.BaseEventData constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_currentInputModule(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.BaseEventData gen_to_be_invoked = (UnityEngine.EventSystems.BaseEventData)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.currentInputModule);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_selectedObject(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.BaseEventData gen_to_be_invoked = (UnityEngine.EventSystems.BaseEventData)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.selectedObject);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_selectedObject(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.BaseEventData gen_to_be_invoked = (UnityEngine.EventSystems.BaseEventData)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.selectedObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_EventSystems_BaseEventDataWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 07540b422925d714185502fd96075084
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_EventSystems_PhysicsRaycasterWrap.cs

@@ -0,0 +1,205 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineEventSystemsPhysicsRaycasterWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.EventSystems.PhysicsRaycaster);
+			Utils.BeginObjectRegister(type, L, translator, 0, 1, 5, 2);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Raycast", _m_Raycast);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventCamera", _g_get_eventCamera);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "depth", _g_get_depth);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "finalEventMask", _g_get_finalEventMask);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventMask", _g_get_eventMask);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxRayIntersections", _g_get_maxRayIntersections);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "eventMask", _s_set_eventMask);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxRayIntersections", _s_set_maxRayIntersections);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "UnityEngine.EventSystems.PhysicsRaycaster does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Raycast(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData));
+                    System.Collections.Generic.List<UnityEngine.EventSystems.RaycastResult> _resultAppendList = (System.Collections.Generic.List<UnityEngine.EventSystems.RaycastResult>)translator.GetObject(L, 3, typeof(System.Collections.Generic.List<UnityEngine.EventSystems.RaycastResult>));
+                    
+                    gen_to_be_invoked.Raycast( _eventData, _resultAppendList );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_eventCamera(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.eventCamera);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_depth(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.depth);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_finalEventMask(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.finalEventMask);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_eventMask(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.eventMask);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_maxRayIntersections(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxRayIntersections);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_eventMask(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+                UnityEngine.LayerMask gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.eventMask = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_maxRayIntersections(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                UnityEngine.EventSystems.PhysicsRaycaster gen_to_be_invoked = (UnityEngine.EventSystems.PhysicsRaycaster)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.maxRayIntersections = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_EventSystems_PhysicsRaycasterWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8dc4c27cde910ea48b0bee690808216e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_EventSystems_PointerEventDataWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d11b850c4ddb85c4fb57222abfe4086f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_EventSystems_UIBehaviourWrap.cs

@@ -0,0 +1,125 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineEventSystemsUIBehaviourWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.EventSystems.UIBehaviour);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsActive", _m_IsActive);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsDestroyed", _m_IsDestroyed);
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "UnityEngine.EventSystems.UIBehaviour does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsActive(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.EventSystems.UIBehaviour gen_to_be_invoked = (UnityEngine.EventSystems.UIBehaviour)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.IsActive(  );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_IsDestroyed(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.EventSystems.UIBehaviour gen_to_be_invoked = (UnityEngine.EventSystems.UIBehaviour)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.IsDestroyed(  );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_EventSystems_UIBehaviourWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 787248acd87266a43ac8777bc61ae771
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_Events_UnityEventWrap.cs

@@ -0,0 +1,170 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLuaBase.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnityEngineEventsUnityEventWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnityEngine.Events.UnityEvent);
+			Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke);
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new UnityEngine.Events.UnityEvent();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Events.UnityEvent constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AddListener(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.Events.UnityAction _call = translator.GetDelegate<UnityEngine.Events.UnityAction>(L, 2);
+                    
+                    gen_to_be_invoked.AddListener( _call );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RemoveListener(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityEngine.Events.UnityAction _call = translator.GetDelegate<UnityEngine.Events.UnityAction>(L, 2);
+                    
+                    gen_to_be_invoked.RemoveListener( _call );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Invoke(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.Invoke(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Client/Assets/Script/3rd/XLua/Gen/UnityEngine_Events_UnityEventWrap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5d6d68c6874980e48ad9327c90b784d3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: