*lua BindToLua

20 files changed, 368 insertions, 368 deletions

diff --git a/Runtime/Scripting/LuaBind.h b/Runtime/Scripting/LuaBind.h
index 1020c69..5b0238e 100644
--- a/Runtime/Scripting/LuaBind.h
+++ b/Runtime/Scripting/LuaBind.h
@@ -2,7 +2,7 @@
 #define __LUA_BIND_H__
 
 ///
-/// LuaBind(port) library 用于给lua注册类和函数
+/// (port) library 用于给lua注册类和函数
 ///
 
 #include "LuaBindState.h" 
diff --git a/Runtime/Scripting/LuaBindCFunctions.h b/Runtime/Scripting/LuaBindCFunctions.h
index 674b9ff..696570e 100644
--- a/Runtime/Scripting/LuaBindCFunctions.h
+++ b/Runtime/Scripting/LuaBindCFunctions.h
@@ -7,7 +7,7 @@
  * luax_cfunction里的函数用来注册给lua，一些特殊功能的通用函数。
 */
 
-namespace LuaBind
+namespace 
 {
 
 	///
diff --git a/Runtime/Scripting/LuaBindClass.cpp b/Runtime/Scripting/LuaBindClass.cpp
index a4d61ad..b6a54b8 100644
--- a/Runtime/Scripting/LuaBindClass.cpp
+++ b/Runtime/Scripting/LuaBindClass.cpp
@@ -7,7 +7,7 @@ namespace LuaBind
 
 #if LUA_BIND_ENABLE_PLAIN_CLASS
 
-	int LuaBindPlainClass::registry(lua_State* L)
+	int PlainClass::registry(lua_State* L)
 	{
 		LUA_BIND_STATE(L);
 
@@ -52,7 +52,7 @@ namespace LuaBind
 		return 1;
 	}
 
-	int LuaBindPlainClass::__tostring(lua_State* L)
+	int PlainClass::__tostring(lua_State* L)
 	{
 		// upvalues: 
 		// 1: class name 
@@ -75,7 +75,7 @@ namespace LuaBind
 	///
 	/// New函数接受n个参数，并尝试获取__init，将参数传给__init初始化实例。
 	/// 
-	int LuaBindPlainClass::_New(lua_State* L)
+	int PlainClass::_New(lua_State* L)
 	{
 		LUA_BIND_STATE(L);
 		
@@ -140,7 +140,7 @@ namespace LuaBind
 		return 1;
 	}
 
-	int LuaBindPlainClass::_Extend(lua_State* L)
+	int PlainClass::_Extend(lua_State* L)
 	{
 		LUA_BIND_STATE(L);
 
@@ -194,7 +194,7 @@ namespace LuaBind
 		return 1;
 	}
 
-	int LuaBindPlainClass::_TypeOf(lua_State* L)
+	int PlainClass::_TypeOf(lua_State* L)
 	{
 		// params: 
 		// 1: lua instance 
diff --git a/Runtime/Scripting/LuaBindClass.hpp b/Runtime/Scripting/LuaBindClass.hpp
index c7cfca5..90c421d 100644
--- a/Runtime/Scripting/LuaBindClass.hpp
+++ b/Runtime/Scripting/LuaBindClass.hpp
@@ -18,33 +18,33 @@
 namespace LuaBind
 {
 
-	class LuaBindVM;
+	class VM;
 
 	///
 	/// 虚基类，为了实现多态。需要访问下面这些接口的外部基类需要虚继承此类，之后再派生链中就会
-	/// 调用对应实体的方法。注意继承此类时不能实现下面的方法，实现在LuaBindNativeClass中，实现会
+	/// 调用对应实体的方法。注意继承此类时不能实现下面的方法，实现在NativeClass中，实现会
 	/// 导致二义性。
 	/// 
 	/// 依据Effective C++条款40，如果在必须使用virtual base基类情况下，应该尽可能避免向其中放
 	/// 置数据成员，规避数据成员初始化造成的一些隐性问题。依据这一点，vpb基类更加接近C#和Java中
 	/// 的Interface。所以，在这里把类用I开头标识这是一个接口。
 	///
-	class LuaBindObject
+	class Object
 	{
 	public:
-		LuaBindObject() {};
-		virtual ~LuaBindObject() {};
+		Object() {};
+		virtual ~Object() {};
 
 		///
 		/// 成员引用管理，在实例的ref table里。设置、取、清除。
 		///
-		virtual bool PushLuaBindMemberRef(LuaBindState& state, int refID) = 0;
-		virtual bool PushLuaBindUserdata(LuaBindState& state) = 0;
-		virtual bool PushLuaBindMemberTable(LuaBindState& state) = 0;
-		virtual bool PushLuaBindRefTable(LuaBindState& state) = 0;
+		virtual bool PushMemberRef(State& state, int refID) = 0;
+		virtual bool PushUserdata(State& state) = 0;
+		virtual bool PushMemberTable(State& state) = 0;
+		virtual bool PushRefTable(State& state) = 0;
 
 		///
-		/// 被LuaBindNativeClass实现。保持和释放native资源。
+		/// 被NativeClass实现。保持和释放native资源。
 		///
 		virtual void Retain() = 0;
 		virtual void Release() = 0;
@@ -52,7 +52,7 @@ namespace LuaBind
 	};
 
 	// TODO: 将公共部分提取出来，不要重复生成代码
-	//class LuaBindNativeClassBase
+	//class NativeClassBase
 	//{
 	//}
 
@@ -60,8 +60,8 @@ namespace LuaBind
 	/// 需要暴露给lua的native class需要继承此类。通过lua管理的实例要确保引用计数的正确性，在多个线程中需要确
 	/// 定不会误释放。
 	///
-	template<class TYPE, class BASE = LuaBindObject>
-	class LuaBindNativeClass : public BASE
+	template<class TYPE, class BASE = Object>
+	class NativeClass : public BASE
 	{
 	public:
 
@@ -70,24 +70,24 @@ namespace LuaBind
 		/// 相比较member ref，这个用在实体会被多次被不同其他实体引用的情况，并频繁销毁这些实体，
 		/// 避免lua频繁的调用gc检测。
 		///
-		template<class DATATYPE> void LuaBindRetain(LuaBindState& state, DATATYPE* userdata);
+		template<class DATATYPE> void Retain(State& state, DATATYPE* userdata);
 
 		///
 		/// 对userdata减少一个引用在ref table里，以尝试回收userdata。
 		/// 
-		template<class DATATYPE> void LuaBindRelease(LuaBindState& state, DATATYPE* userdata);
+		template<class DATATYPE> void Release(State& state, DATATYPE* userdata);
 
 		///
 		/// 将userdata push到栈顶，如果没有初始化mUserdata，初始化设置好元表并把初始化好的
 		/// userdata留在栈顶。并添加一个引用。这是一个将native对象所有权移交给lua控制的方法。
 		///
-		bool PushLuaBindMemberRef(LuaBindState& state, int refID) override;
-		bool PushLuaBindUserdata(LuaBindState& state) override;
-		bool PushLuaBindMemberTable(LuaBindState& state) override;
-		bool PushLuaBindRefTable(LuaBindState& state) override;
+		bool PushMemberRef(State& state, int refID) override;
+		bool PushUserdata(State& state) override;
+		bool PushMemberTable(State& state) override;
+		bool PushRefTable(State& state) override;
 
 		///
-		/// Watch dog 添加一个native引用。luaVM引用不会提供外部接口。继承此类的派生类不能直接使用
+		/// WatchDog添加一个native引用。luaVM引用不会提供外部接口。继承此类的派生类不能直接使用
 		/// delete方法，应该使用Release释放。一般情况下这个操作由虚拟机__gc进行，但是允许用户
 		/// 程序在native中隔绝虚拟机情况下释放，这种情况下要使用Release。
 		/// 
@@ -103,31 +103,31 @@ namespace LuaBind
 
 	protected:
 
-		LuaBindNativeClass();
-		virtual ~LuaBindNativeClass();
+		NativeClass();
+		virtual ~NativeClass();
 
 		///
 		/// 成员引用管理，在实例的ref table里。设置、取、清除
 		///
-		void SetLuaBindMemberRef(LuaBindState& state, LuaBindMemberRef& memRef, int idx);
-		bool PushLuaBindMemberRef(LuaBindState& state, LuaBindMemberRef& memRef);
-		void ClearLuaBindMemberRef(LuaBindState& state, LuaBindMemberRef& memRef);
+		void SetMemberRef(State& state, MemberRef& memRef, int idx);
+		bool PushMemberRef(State& state, MemberRef& memRef);
+		void ClearMemberRef(State& state, MemberRef& memRef);
 
 	private:
 
-		friend class LuaBindState;
+		friend class State;
 
-		static void RegisterLuaBindClassShared(LuaBindState& state);
-		static void RegisterLuaBindFactoryClass(LuaBindState& state);
-		static void RegisterLuaBindSingletonClass(LuaBindState& state);
+		static void RegisterClassShared(State& state);
+		static void RegisterFactoryClass(State& state);
+		static void RegisterSingletonClass(State& state);
 
-		static void SetLuaBindClassTableRef(LuaBindState& state, int idx);
-		static void PushLuaBindClassTable(LuaBindState& state);
+		static void SetClassTableRef(State& state, int idx);
+		static void PushClassTable(State& state);
 
 		///
 		/// 创建userdata，绑定实例到state。
 		///
-		void BindToLua(LuaBindState& state);
+		void BindToLua(State& state);
 
 		//------------------------------------------------------------------------------//
 
@@ -151,15 +151,15 @@ namespace LuaBind
 		///
 		/// class table，工厂和单例都有。
 		///
-		static LuaBindStrongRef mClassTable;
+		static StrongRef mClassTable;
 
 		///
 		/// 如果类是单例，这个用来保存singleton的引用关系，以保证不会被回收类似普通类的ref table。
 		/// 单例的成员是全生命周期的，所以直接在_LUA_BIND_STRONGREF_TABLE。单例对userdata进行
-		/// LuaBindRetain\LuaBindRelease和member ref操作时和工厂实例不同，是存在下面这个ref table里
+		/// Retain\Release和member ref操作时和工厂实例不同，是存在下面这个ref table里
 		/// 的，这个table在_LUA_BIND_STRONGREF_TABLE里。
 		///
-		static LuaBindStrongRef mSingletonRefTable;
+		static StrongRef mSingletonRefTable;
 
 		///
 		/// 通过userdata可以拿到:
@@ -167,14 +167,14 @@ namespace LuaBind
 		///     2: member table 
 		///     3: class table
 		///
-		LuaBindWeakRef mUserdata;
+		WeakRef mUserdata;
 
 		/// 通过后才能删除
-		LuaBindWatchDog mWatchDog;
+		WatchDog mWatchDog;
 
 #if LUA_BIND_PROFILER
 		// 托管此对象的虚拟机
-		std::unordered_set<LuaBindVM*> mRefVMs;
+		std::unordered_set<VM*> mRefVMs;
 		// 保险，此类的派生类不能在外部使用delete直接删除，而应该使用Release
 		bool mSafer;
 #endif
@@ -185,7 +185,7 @@ namespace LuaBind
 	///
 	/// 纯lua类
 	///
-	class LuaBindPlainClass
+	class PlainClass
 	{
 	public:
 
diff --git a/Runtime/Scripting/LuaBindClass.inc b/Runtime/Scripting/LuaBindClass.inc
index faa276d..e9c7b8b 100644
--- a/Runtime/Scripting/LuaBindClass.inc
+++ b/Runtime/Scripting/LuaBindClass.inc
@@ -7,11 +7,11 @@ namespace LuaBind
 	/// 对不同类型，通过调用GetLuaClassName获得类型名，如果是派生类，GetClassName会被覆盖，指向luax_c_getupvalue。
 	///
 	template<class TYPE, class BASE>
-	int LuaBindNativeClass<TYPE, BASE>::_GetClassName(lua_State* L)
+	int NativeClass<TYPE, BASE>::_GetClassName(lua_State* L)
 	{
 		LUA_BIND_SETUP(L, "*");
 
-		cc8* type = TYPE::GetLuaBindClassName();
+		cc8* type = TYPE::GetClassName();
 		state.Push(type);
 		return 1;
 	}
@@ -22,7 +22,7 @@ namespace LuaBind
 	/// 注册工厂和单例共有的类成员
 	/// 
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::RegisterLuaBindClassShared(LuaBindState& state)
+	void NativeClass<TYPE, BASE>::RegisterClassShared(State& state)
 	{
 		luaL_Reg regTable[] = {
 			{ "GetClass",     _GetClass     },
@@ -37,7 +37,7 @@ namespace LuaBind
 	/// 工厂类的成员，注册在class table
 	///
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::RegisterLuaBindFactoryClass(LuaBindState& state)
+	void NativeClass<TYPE, BASE>::RegisterFactoryClass(State& state)
 	{
 		luaL_Reg regTable[] = {
 			{ "GetRefTable", _GetRefTable },
@@ -51,7 +51,7 @@ namespace LuaBind
 	/// 单例类的成员，注册在class table
 	///
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::RegisterLuaBindSingletonClass(LuaBindState& state)
+	void NativeClass<TYPE, BASE>::RegisterSingletonClass(State& state)
 	{
 		luaL_Reg regTable[] = {
 			{ NULL, NULL }
@@ -61,7 +61,7 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::PushLuaBindClassTable(LuaBindState& state)
+	void NativeClass<TYPE, BASE>::PushClassTable(State& state)
 	{
 		assert(mClassTable);
 
@@ -69,13 +69,13 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::SetLuaBindClassTableRef(LuaBindState& state, int idx)
+	void NativeClass<TYPE, BASE>::SetClassTableRef(State& state, int idx)
 	{
 		mClassTable.SetRef(state, idx);
 	}
 
 	template<class TYPE, class BASE>
-	LuaBindNativeClass<TYPE, BASE>::LuaBindNativeClass()
+	NativeClass<TYPE, BASE>::NativeClass()
 		: mWatchDog() 
 #if LUA_BIND_PROFILER 
 		, mSafer(false)
@@ -84,13 +84,13 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	LuaBindNativeClass<TYPE, BASE>::~LuaBindNativeClass()
+	NativeClass<TYPE, BASE>::~NativeClass()
 	{
 	}
 
 #if LUA_BIND_PROFILER
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::operator delete(void* pdead, size_t size)
+	void NativeClass<TYPE, BASE>::operator delete(void* pdead, size_t size)
 	{
 		if (pdead == nullptr)
 			return;
@@ -102,13 +102,13 @@ namespace LuaBind
 #endif
 
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::Retain()
+	void NativeClass<TYPE, BASE>::Retain()
 	{
 		++mWatchDog.mNativeRef;
 	}
 
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::Release()
+	void NativeClass<TYPE, BASE>::Release()
 	{
 		if (mWatchDog.mNativeRef > 0)
 			--mWatchDog.mNativeRef;
@@ -123,11 +123,11 @@ namespace LuaBind
 
 	template<class TYPE, class BASE>
 	template<typename U>
-	void LuaBindNativeClass<TYPE, BASE>::LuaBindRetain(LuaBindState& state, U* userdata)
+	void NativeClass<TYPE, BASE>::Retain(State& state, U* userdata)
 	{
-		if (PushLuaBindRefTable(state))
+		if (PushRefTable(state))
 		{
-			if (userdata->PushLuaBindUserdata(state))
+			if (userdata->PushUserdata(state))
 			{
 				lua_pushvalue(state, -1); // copy the userdata
 				lua_gettable(state, -3); // get the count (or nil)
@@ -141,11 +141,11 @@ namespace LuaBind
 
 	template<class TYPE, class BASE>
 	template<typename U>
-	void LuaBindNativeClass<TYPE, BASE>::LuaBindRelease(LuaBindState& state, U* userdata)
+	void NativeClass<TYPE, BASE>::Release(State& state, U* userdata)
 	{
-		if (PushLuaBindRefTable(state))
+		if (PushRefTable(state))
 		{
-			if (userdata->PushLuaBindUserdata(state))
+			if (userdata->PushUserdata(state))
 			{
 				lua_pushvalue(state, -1); // copy the userdata
 				lua_gettable(state, -3); // get the count (or nil)
@@ -176,9 +176,9 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	bool LuaBindNativeClass<TYPE, BASE>::PushLuaBindUserdata(LuaBindState& state)
+	bool NativeClass<TYPE, BASE>::PushUserdata(State& state)
 	{
-		assert(!TYPE::IsLuaBindClassSingleton());
+		assert(!TYPE::IsClassSingleton());
 		if (!mUserdata)
 		{
 			BindToLua(state);
@@ -188,10 +188,10 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	bool LuaBindNativeClass<TYPE, BASE>::PushLuaBindMemberTable(LuaBindState& state)
+	bool NativeClass<TYPE, BASE>::PushMemberTable(State& state)
 	{
 		int top = state.GetTop();
-		if (this->PushLuaBindUserdata(state))
+		if (this->PushUserdata(state))
 		{
 			if (lua_getmetatable(state, -1))  // ref table 
 			{
@@ -209,10 +209,10 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	bool LuaBindNativeClass<TYPE, BASE>::PushLuaBindRefTable(LuaBindState& state)
+	bool NativeClass<TYPE, BASE>::PushRefTable(State& state)
 	{
 		// Singleton 
-		if (TYPE::IsLuaBindClassSingleton())
+		if (TYPE::IsClassSingleton())
 		{
 			if (!this->mSingletonRefTable) {
 				lua_newtable(state);
@@ -226,7 +226,7 @@ namespace LuaBind
 		// Factory
 		else 
 		{
-			if (this->PushLuaBindUserdata(state))
+			if (this->PushUserdata(state))
 			{
 				if (lua_getmetatable(state, -1))
 				{
@@ -248,10 +248,10 @@ namespace LuaBind
 	/// BindToLua只会在第一次注册给Lua虚拟机时调用。
 	///
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::BindToLua(LuaBindState& state)
+	void NativeClass<TYPE, BASE>::BindToLua(State& state)
 	{
 		// 单例不能绑定userdata
-		assert(!TYPE::IsLuaBindClassSingleton());
+		assert(!TYPE::IsClassSingleton());
 		assert(!mUserdata);
 
 		///
@@ -264,7 +264,7 @@ namespace LuaBind
 
 		lua_newtable(state); // ref table，无法在lua处访问，用来管理C对象的生命周期
 		lua_newtable(state); // member table，lua中创建的对象成员都保存在这里
-		PushLuaBindClassTable(state); // class table
+		PushClassTable(state); // class table
 
 		// stack:
 		// -1: class table
@@ -310,13 +310,13 @@ namespace LuaBind
 	/// 成员引用管理
 	///
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::SetLuaBindMemberRef(LuaBindState& state, LuaBindMemberRef& memRef, int idx)
+	void NativeClass<TYPE, BASE>::SetMemberRef(State& state, MemberRef& memRef, int idx)
 	{
-		ClearLuaBindMemberRef(state, memRef);
+		ClearMemberRef(state, memRef);
 		if (!lua_isnil(state, idx))
 		{
 			idx = state.AbsIndex(idx);
-			if (PushLuaBindRefTable(state))
+			if (PushRefTable(state))
 			{
 				lua_pushvalue(state, idx);
 				memRef.refID = luaL_ref(state, -2);
@@ -326,11 +326,11 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	bool LuaBindNativeClass<TYPE, BASE>::PushLuaBindMemberRef(LuaBindState& state, LuaBindMemberRef& memRef)
+	bool NativeClass<TYPE, BASE>::PushMemberRef(State& state, MemberRef& memRef)
 	{
 		if (memRef)
 		{
-			if (PushLuaBindRefTable(state))
+			if (PushRefTable(state))
 			{
 				lua_rawgeti(state, -1, memRef.refID);
 				lua_replace(state, -2); // ref table
@@ -346,9 +346,9 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE> 
-	bool LuaBindNativeClass<TYPE, BASE>::PushLuaBindMemberRef(LuaBindState& state, int refID)
+	bool NativeClass<TYPE, BASE>::PushMemberRef(State& state, int refID)
 	{
-		if (PushLuaBindRefTable(state))
+		if (PushRefTable(state))
 		{
 			lua_rawgeti(state, -1, refID);
 			lua_replace(state, -2); // ref table
@@ -362,11 +362,11 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	void LuaBindNativeClass<TYPE, BASE>::ClearLuaBindMemberRef(LuaBindState& state, LuaBindMemberRef& memRef)
+	void NativeClass<TYPE, BASE>::ClearMemberRef(State& state, MemberRef& memRef)
 	{
 		if (memRef)
 		{
-			if (PushLuaBindRefTable(state))
+			if (PushRefTable(state))
 			{
 				luaL_unref(state, -1, memRef.refID);
 				state.Pop(); // ref table
@@ -381,7 +381,7 @@ namespace LuaBind
 	/// 释放工厂创建的实例
 	///
 	template<class TYPE, class BASE>
-	int LuaBindNativeClass<TYPE, BASE>::__gc(lua_State* L)
+	int NativeClass<TYPE, BASE>::__gc(lua_State* L)
 	{
 		LUA_BIND_STATE(L);
 
@@ -389,7 +389,7 @@ namespace LuaBind
 		assert(self);
 
 #if LUA_BIND_PROFILER 
-		std::cout << "LuaBind: GC<" << TYPE::GetLuaBindClassName() << ">\n";
+		std::cout << ": GC<" << TYPE::GetClassName() << ">\n";
 #endif
 
 		if(self->mWatchDog.mVMRef > 0)
@@ -405,7 +405,7 @@ namespace LuaBind
 	/// 地址 类名
 	///
 	template<class TYPE, class BASE>
-	int LuaBindNativeClass<TYPE, BASE>::__tostring(lua_State* L)
+	int NativeClass<TYPE, BASE>::__tostring(lua_State* L)
 	{
 		// params: 
 		// 1: userdata
@@ -424,7 +424,7 @@ namespace LuaBind
 			}
 			else
 			{
-				classname = TYPE::GetLuaBindClassName();
+				classname = TYPE::GetClassName();
 			}
 			lua_pushfstring(L, "%s: %p", classname, self);
 			return 1;
@@ -438,7 +438,7 @@ namespace LuaBind
 	/// native实体创建后可以使用__init进行初始化，派生类拥有和基类一样的New参数列表，且native对象是一样的类型。
 	///
 	template<class TYPE, class BASE>
-	int LuaBindNativeClass<TYPE, BASE>::_ExtendFactory(lua_State* L)
+	int NativeClass<TYPE, BASE>::_ExtendFactory(lua_State* L)
 	{
 		// upvalues:
 		// 1: base class 
@@ -490,7 +490,7 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	int LuaBindNativeClass<TYPE, BASE>::_ExtendSingleton(lua_State* L)
+	int NativeClass<TYPE, BASE>::_ExtendSingleton(lua_State* L)
 	{
 		// upvalues:
 		// 1: base class 
@@ -537,7 +537,7 @@ namespace LuaBind
 #endif /*LUA_BIND_ENABLE_NATIVE_EXTEND*/
 
 	template<class TYPE, class BASE> 
-	int LuaBindNativeClass<TYPE, BASE>::_GetClass(lua_State* L)
+	int NativeClass<TYPE, BASE>::_GetClass(lua_State* L)
 	{
 		LUA_BIND_STATE(L);
 		if (!mClassTable)
@@ -548,18 +548,18 @@ namespace LuaBind
 	}
 
 	template<class TYPE, class BASE>
-	int LuaBindNativeClass<TYPE, BASE>::_GetRefTable(lua_State* L)
+	int NativeClass<TYPE, BASE>::_GetRefTable(lua_State* L)
 	{
 		LUA_BIND_STATE(L);
 		TYPE* self = state.GetUserdata<TYPE>(1);
-		bool success = self->PushLuaBindRefTable(state);
+		bool success = self->PushRefTable(state);
 		if (!success)
 			lua_pushnil(L);
 		return 1;
 	}
 
 	template<class TYPE, class BASE>
-	int LuaBindNativeClass<TYPE, BASE>::_New(lua_State* L)
+	int NativeClass<TYPE, BASE>::_New(lua_State* L)
 	{
 		LUA_BIND_STATE(L);
 
@@ -631,7 +631,7 @@ namespace LuaBind
 		return 0;
 	}
 
-	template<class TYPE, class BASE> LuaBindStrongRef LuaBindNativeClass<TYPE, BASE>::mClassTable;        // class table
-	template<class TYPE, class BASE> LuaBindStrongRef LuaBindNativeClass<TYPE, BASE>::mSingletonRefTable; // 单例
+	template<class TYPE, class BASE> StrongRef NativeClass<TYPE, BASE>::mClassTable;        // class table
+	template<class TYPE, class BASE> StrongRef NativeClass<TYPE, BASE>::mSingletonRefTable; // 单例
 
 }
\ No newline at end of file
diff --git a/Runtime/Scripting/LuaBindEnum.cpp b/Runtime/Scripting/LuaBindEnum.cpp
index 18fcee7..ecf4a9f 100644
--- a/Runtime/Scripting/LuaBindEnum.cpp
+++ b/Runtime/Scripting/LuaBindEnum.cpp
@@ -36,7 +36,7 @@ namespace LuaBind
 
 	//--------------------------------------------------------------------------------//
 #if LUA_BIND_ENABLE_PLAIN_ENUM
-	int LuaBindPlainEnum::registry(lua_State* L)
+	int PlainEnum::registry(lua_State* L)
 	{
 		// params:
 		// 1: enum name
diff --git a/Runtime/Scripting/LuaBindEnum.h b/Runtime/Scripting/LuaBindEnum.h
index b52f2c3..dbbd2f2 100644
--- a/Runtime/Scripting/LuaBindEnum.h
+++ b/Runtime/Scripting/LuaBindEnum.h
@@ -9,7 +9,7 @@ namespace LuaBind
 	///
 	/// 导出枚举，枚举是一类不可修改整型集合，枚举的值在
 	///
-	struct LuaBindEnum
+	struct Enum
 	{
 		cc8* name;
 		int  value;
@@ -25,7 +25,7 @@ namespace LuaBind
 	///
 	/// 纯lua的枚举，创建不可修改的table
 	///
-	class LuaBindPlainEnum
+	class PlainEnum
 	{
 	public:
 
diff --git a/Runtime/Scripting/LuaBindMemberRef.cpp b/Runtime/Scripting/LuaBindMemberRef.cpp
index 618c125..e680cce 100644
--- a/Runtime/Scripting/LuaBindMemberRef.cpp
+++ b/Runtime/Scripting/LuaBindMemberRef.cpp
@@ -3,12 +3,12 @@
 namespace LuaBind
 {
 
-	LuaBindMemberRef::LuaBindMemberRef()
+	MemberRef::MemberRef()
 		: refID(LUA_NOREF)
 	{
 	}
 
-	LuaBindMemberRef::~LuaBindMemberRef()
+	MemberRef::~MemberRef()
 	{
 
 	}
diff --git a/Runtime/Scripting/LuaBindMemberRef.h b/Runtime/Scripting/LuaBindMemberRef.h
index ea60633..9dbd36b 100644
--- a/Runtime/Scripting/LuaBindMemberRef.h
+++ b/Runtime/Scripting/LuaBindMemberRef.h
@@ -10,11 +10,11 @@ namespace LuaBind
 	/// 实例的ref table保存的member ref。由luax class做具体的管理。实例的ref table是强引用，用来管理里面member的生命周期。
 	/// 用来在lua和native之间进行数据沟通。
 	///
-	class LuaBindMemberRef
+	class MemberRef
 	{
 	public:
-		LuaBindMemberRef();
-		~LuaBindMemberRef();
+		MemberRef();
+		~MemberRef();
 
 		inline operator bool() { return refID != LUA_NOREF; };
 
diff --git a/Runtime/Scripting/LuaBindRef.cpp b/Runtime/Scripting/LuaBindRef.cpp
index f6ff8a1..00a65d0 100644
--- a/Runtime/Scripting/LuaBindRef.cpp
+++ b/Runtime/Scripting/LuaBindRef.cpp
@@ -4,35 +4,35 @@
 namespace LuaBind
 {
 
-	LuaBindRef::LuaBindRef(int mode)
+	Ref::Ref(int mode)
 		: mRefID(LUA_NOREF)
 		, mMode(mode)
 	{
 	}
 
-	LuaBindRef::~LuaBindRef()
+	Ref::~Ref()
 	{
 	}
 
-	LuaBindRef::operator bool()
+	Ref::operator bool()
 	{
 		return (mRefID != LUA_NOREF);
 	}
 
-	bool LuaBindRef::PushRef(LuaBindState& state)
+	bool Ref::PushRef(State& state)
 	{
 		assert(mRefID != LUA_NOREF);
 
-		LuaBindVM* vm = state.GetVM();
+		VM* vm = state.GetVM();
 		if (!vm) return false;
 		if (mMode == STRONG_REF)
 		{
-			LuaBindRefTable& table = vm->GetStrongRefTable();
+			RefTable& table = vm->GetStrongRefTable();
 			table.PushRef(state, mRefID);
 		}
 		else if (mMode == WEAK_REF)
 		{
-			LuaBindRefTable& table = vm->GetWeakRefTable();
+			RefTable& table = vm->GetWeakRefTable();
 			table.PushRef(state, mRefID);
 		}
 		else
@@ -43,29 +43,29 @@ namespace LuaBind
 		return true;
 	}
 
-	void LuaBindRef::SetRef(LuaBindState& state, int idx)
+	void Ref::SetRef(State& state, int idx)
 	{
-		LuaBindVM* vm = state.GetVM();
+		VM* vm = state.GetVM();
 		if (!vm) return;
 		if (mMode == STRONG_REF)
 		{
-			LuaBindRefTable& table = vm->GetStrongRefTable();
+			RefTable& table = vm->GetStrongRefTable();
 			mRefID = table.Ref(state, idx);
 		}
 		else if (mMode == WEAK_REF)
 		{
-			LuaBindRefTable& table = vm->GetWeakRefTable();
+			RefTable& table = vm->GetWeakRefTable();
 			mRefID = table.Ref(state, idx);
 		}
 	}
 
-	LuaBindStrongRef::LuaBindStrongRef()
-		: LuaBindRef(STRONG_REF)
+	StrongRef::StrongRef()
+		: Ref(STRONG_REF)
 	{
 	}
 
-	LuaBindWeakRef::LuaBindWeakRef()
-		: LuaBindRef(WEAK_REF)
+	WeakRef::WeakRef()
+		: Ref(WEAK_REF)
 	{
 	}
 
diff --git a/Runtime/Scripting/LuaBindRef.h b/Runtime/Scripting/LuaBindRef.h
index 529cd82..7628547 100644
--- a/Runtime/Scripting/LuaBindRef.h
+++ b/Runtime/Scripting/LuaBindRef.h
@@ -10,7 +10,7 @@ namespace LuaBind
 	///
 	/// 引用，存在LUA_REGISTRYINDEX下面的两个表里
 	///
-	class LuaBindRef
+	class Ref
 	{
 	public:
 
@@ -20,13 +20,13 @@ namespace LuaBind
 			WEAK_REF
 		};
 		
-		LuaBindRef(int mode = STRONG_REF);
-		virtual ~LuaBindRef();
+		Ref(int mode = STRONG_REF);
+		virtual ~Ref();
 
 		operator bool();
 
-		void SetRef(LuaBindState& state, int idx);
-		bool PushRef(LuaBindState& state);
+		void SetRef(State& state, int idx);
+		bool PushRef(State& state);
 
 		int GetRefID();
 
@@ -40,20 +40,20 @@ namespace LuaBind
 	///
 	/// 强引用，在LUA_REGISTRYINDEX["_LUA_BIND_STRONGREF_TABLE"]里，保证lua object不会被回收。
 	///
-	class LuaBindStrongRef: public LuaBindRef
+	class StrongRef: public Ref
 	{
 	public:
-		LuaBindStrongRef();
+		StrongRef();
 
 	};
 
 	///
 	/// 弱引用，在LUA_REGISTRYINDEX["_LUA_BIND_WEAKREF_TABLE"]里，不影响lua object的回收，只是作为一个方便取lua object的映射。
 	///
-	class LuaBindWeakRef : public LuaBindRef
+	class WeakRef : public Ref
 	{
 	public:
-		LuaBindWeakRef();
+		WeakRef();
 
 	};
 
diff --git a/Runtime/Scripting/LuaBindRefTable.cpp b/Runtime/Scripting/LuaBindRefTable.cpp
index 13b9c2c..39ef9ab 100644
--- a/Runtime/Scripting/LuaBindRefTable.cpp
+++ b/Runtime/Scripting/LuaBindRefTable.cpp
@@ -4,16 +4,16 @@
 namespace LuaBind
 {
 
-	LuaBindRefTable::LuaBindRefTable()
+	RefTable::RefTable()
 		: mState(nullptr)
 	{
 	}
 
-	LuaBindRefTable::~LuaBindRefTable()
+	RefTable::~RefTable()
 	{
 	}
 
-	void LuaBindRefTable::Init(LuaBindState& state, cc8* name, cc8* mode)
+	void RefTable::Init(State& state, cc8* name, cc8* mode)
 	{
 		assert(!mState);
 		assert(name);
@@ -56,21 +56,21 @@ namespace LuaBind
 		}
 	}
 
-	bool LuaBindRefTable::IsKeyWeak()
+	bool RefTable::IsKeyWeak()
 	{
 		assert(mState);
 
 		return mMode & WEAK_KEY;
 	}
 
-	bool LuaBindRefTable::IsValueWeak()
+	bool RefTable::IsValueWeak()
 	{
 		assert(mState);
 
 		return mMode & WEAK_VALUE;
 	}
 
-	int LuaBindRefTable::Ref(LuaBindState& state, int idx)
+	int RefTable::Ref(State& state, int idx)
 	{
 		assert(mState);
 
@@ -83,7 +83,7 @@ namespace LuaBind
 		return refID;
 	}
 
-	void LuaBindRefTable::Unref(LuaBindState& state, int refID)
+	void RefTable::Unref(State& state, int refID)
 	{
 		assert(mState);
 
@@ -93,14 +93,14 @@ namespace LuaBind
 		return;
 	}
 
-	void LuaBindRefTable::PushRefTable(LuaBindState& state)
+	void RefTable::PushRefTable(State& state)
 	{
 		assert(mState);
 
 		lua_getfield(state, LUA_REGISTRYINDEX, mName);
 	}
 
-	void LuaBindRefTable::PushRef(LuaBindState& state, int refID)
+	void RefTable::PushRef(State& state, int refID)
 	{
 		assert(mState);
 
@@ -109,7 +109,7 @@ namespace LuaBind
 		lua_replace(state, -2);
 	}
 
-	void LuaBindRefTable::Clear(LuaBindState& state)
+	void RefTable::Clear(State& state)
 	{
 		assert(mState);
 
diff --git a/Runtime/Scripting/LuaBindRefTable.h b/Runtime/Scripting/LuaBindRefTable.h
index 95a21f9..1cc2af3 100644
--- a/Runtime/Scripting/LuaBindRefTable.h
+++ b/Runtime/Scripting/LuaBindRefTable.h
@@ -6,12 +6,12 @@
 namespace LuaBind
 {
 
-	class LuaBindState;
+	class State;
 
 	///
 	/// ref table 管理，对strong ref table和weak ref table两个table的代理。
 	///
-	class LuaBindRefTable
+	class RefTable
 	{
 	public:
 
@@ -21,12 +21,12 @@ namespace LuaBind
 			WEAK_VALUE = 1 << 1
 		};
 
-		LuaBindRefTable();
-		~LuaBindRefTable();
+		RefTable();
+		~RefTable();
 
 		inline operator bool() { return mState; };
 
-		void Init(LuaBindState& state, cc8* name, cc8* mode = nullptr);
+		void Init(State& state, cc8* name, cc8* mode = nullptr);
 
 		bool IsKeyWeak();
 		bool IsValueWeak();
@@ -34,27 +34,27 @@ namespace LuaBind
 		///
 		/// 对stack[idx]的实体在此ref table中增加一个引用，并返回refID
 		///
-		int Ref(LuaBindState& state, int idx);
-		void Unref(LuaBindState& state, int refID);
+		int Ref(State& state, int idx);
+		void Unref(State& state, int refID);
 
 		///
 		/// 将此 ref table 放在栈顶
 		///
-		void PushRefTable(LuaBindState& state);
+		void PushRefTable(State& state);
 
 		///
 		/// 将 reftable[refID] 放在栈顶
 		///
-		void PushRef(LuaBindState& state, int refID);
+		void PushRef(State& state, int refID);
 
 		///
 		/// 清空 ref table，表还留在LUA_REGISTRYINDEX[mName]
 		///
-		void Clear(LuaBindState& state);
+		void Clear(State& state);
 
 	private:
 
-		friend class LuaBindState;
+		friend class State;
 
 		lua_State* mState; // 用来做一些确认工作
 		cc8*       mName;  // ref table的名称
diff --git a/Runtime/Scripting/LuaBindState.cpp b/Runtime/Scripting/LuaBindState.cpp
index 845cf29..2b699f5 100644
--- a/Runtime/Scripting/LuaBindState.cpp
+++ b/Runtime/Scripting/LuaBindState.cpp
@@ -7,38 +7,38 @@
 namespace LuaBind
 {
 	
-	LuaBindState::LuaBindState(lua_State* state)
+	State::State(lua_State* state)
 		: mState(state) 
 	{
 		assert(state);
 	}
 
-	LuaBindState::LuaBindState(const LuaBindState& state)
+	State::State(const State& state)
 		: mState(state.mState)
 	{
 		assert(state.mState);
 	}
 
-	LuaBindState::~LuaBindState()
+	State::~State()
 	{
 	}
 
-	void LuaBindState::OpenLibs()
+	void State::OpenLibs()
 	{
 		luaL_openlibs(mState);
 	}
 
-	global_State* LuaBindState::GetGlobalState()
+	global_State* State::GetGlobalState()
 	{
 		return G(mState);
 	}
 
-	LuaBindVM* LuaBindState::GetVM()
+	VM* State::GetVM()
 	{
-		return LuaBindVM::TryGetVM(G(mState));
+		return VM::TryGetVM(G(mState));
 	}
 
-	void LuaBindState::PushGlobalNamespace()
+	void State::PushGlobalNamespace()
 	{
 		int top = GetTop();
 
@@ -61,7 +61,7 @@ namespace LuaBind
 		// -1 pseudo global namespace
 	}
 
-	void LuaBindState::PushNamespace(cc8* name)
+	void State::PushNamespace(cc8* name)
 	{
 		assert(IsNamespace(-1));
 
@@ -81,23 +81,23 @@ namespace LuaBind
 		// -1 namespace
 	}
 
-	void LuaBindState::PopNamespace()
+	void State::PopNamespace()
 	{
 		assert(lua_istable(mState, -1));
 		lua_pop(mState, 1);
 	}
 
-	bool LuaBindState::IsNamespace(int idx)
+	bool State::IsNamespace(int idx)
 	{
 		return lua_istable(mState, idx);
 	}
 
-	void LuaBindState::DoString(const std::string& code)
+	void State::DoString(const std::string& code)
 	{
 		luaL_dostring(mState, code.c_str());
 	}
 
-	int LuaBindState::AbsIndex(int idx)
+	int State::AbsIndex(int idx)
 	{
 /*
 #define abs_index(mState, i)		((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
@@ -111,116 +111,116 @@ namespace LuaBind
 		return idx;
 	}
 
-	void LuaBindState::Call(int nArgs, int nResults)
+	void State::Call(int nArgs, int nResults)
 	{
 		lua_pcall(mState, nArgs, nResults, 0);
 	}
 
-	void LuaBindState::PushNil() 
+	void State::PushNil() 
 	{
 		lua_pushnil(mState);
 	}
 
-	void LuaBindState::Push(bool value) 
+	void State::Push(bool value) 
 	{
 		lua_pushboolean(mState, value ? 1 : 0);
 	}
 
-	void LuaBindState::Push(cc8* value) 
+	void State::Push(cc8* value) 
 	{
 		lua_pushstring(mState, value);
 	}
 
-	void LuaBindState::Push(double value) 
+	void State::Push(double value) 
 	{
 		lua_pushnumber(mState, value);
 	}
 
-	void LuaBindState::Push(float value) 
+	void State::Push(float value) 
 	{
 		lua_pushnumber(mState, value);
 	}
 
-	void LuaBindState::Push(int value) 
+	void State::Push(int value) 
 	{
 		lua_pushnumber(mState, value);
 	}
 
-	void LuaBindState::Push(u16 value) 
+	void State::Push(u16 value) 
 	{
 		lua_pushnumber(mState, value);
 	}
 
-	void LuaBindState::Push(u32 value) 
+	void State::Push(u32 value) 
 	{
 		lua_pushnumber(mState, value);
 	}
 
-	void LuaBindState::Push(u64 value) 
+	void State::Push(u64 value) 
 	{
 		lua_pushnumber(mState, (double)value);
 	}
 
-	void LuaBindState::Push(s64 value)
+	void State::Push(s64 value)
 	{
 		lua_pushinteger(mState, value);
 	}
 
-	void LuaBindState::Push(uintptr value) 
+	void State::Push(uintptr value) 
 	{
 		lua_pushlightuserdata(mState, (void*)value);
 	}
 
-	void LuaBindState::Push(lua_CFunction value) 
+	void State::Push(lua_CFunction value) 
 	{
 		lua_pushcfunction(mState, value);
 	}
 
-	void LuaBindState::Push(void* data, size_t size)
+	void State::Push(void* data, size_t size)
 	{
 		lua_pushlstring(mState, (cc8*)data, size);
 	}
 
-	void LuaBindState::Push(const void* value)
+	void State::Push(const void* value)
 	{
 		lua_pushlightuserdata(mState, (void*)value);
 	}
 
-	void LuaBindState::Push(std::string value)
+	void State::Push(std::string value)
 	{
 		Push(value.c_str());
 	}
 
-	void LuaBindState::PushValues(int idx, int n)
+	void State::PushValues(int idx, int n)
 	{
 		idx = AbsIndex(idx);
 		for (int i = idx; i < idx + n; ++i)
 			lua_pushvalue(mState, i);
 	}
 
-	void LuaBindState::Pop(int n /* = 1 */)
+	void State::Pop(int n /* = 1 */)
 	{
 		lua_pop(mState, n);
 	}
 
-	bool LuaBindState::IsNil(int idx) 
+	bool State::IsNil(int idx) 
 	{
 		return lua_isnil(mState, idx);
 	}
 
-	bool LuaBindState::IsNilOrNone(int idx) 
+	bool State::IsNilOrNone(int idx) 
 	{
 		int t = lua_type(mState, idx);
 		return ((t == LUA_TNONE) || (t == LUA_TNIL));
 	}
 
-	bool LuaBindState::IsTableOrUserdata(int idx) 
+	bool State::IsTableOrUserdata(int idx) 
 	{
 		int check = lua_type(mState, idx);
 		return ((check == LUA_TTABLE) || (check == LUA_TUSERDATA));
 	}
 
-	bool LuaBindState::IsTrueOrNotNil(int idx) 
+	bool State::IsTrueOrNotNil(int idx) 
 	{
 		if (lua_isboolean(mState, idx)) {
 			return lua_toboolean(mState, idx) ? true : false;
@@ -228,32 +228,32 @@ namespace LuaBind
 		return !lua_isnil(mState, idx);
 	}
 
-	bool LuaBindState::IsType(int idx, int type) 
+	bool State::IsType(int idx, int type) 
 	{
 		return (lua_type(mState, idx) == type);
 	}
 
-	bool LuaBindState::IsType(int idx, cc8* name, int type) 
+	bool State::IsType(int idx, cc8* name, int type) 
 	{
 		return this->HasField(idx, name, type);
 	}
 
-	bool LuaBindState::IsValid() 
+	bool State::IsValid() 
 	{
 		return (mState != 0);
 	}
 
-	void LuaBindState::Settop(int idx)
+	void State::Settop(int idx)
 	{
 		lua_settop(mState, idx);
 	}
 
-	int LuaBindState::GetTop()
+	int State::GetTop()
 	{
 		return lua_gettop(mState);
 	}
 
-	bool LuaBindState::HasField(int idx, cc8* name) {
+	bool State::HasField(int idx, cc8* name) {
 
 		lua_getfield(mState, idx, name);
 		bool hasField = (lua_isnil(mState, -1) == false);
@@ -262,7 +262,7 @@ namespace LuaBind
 		return hasField;
 	}
 
-	bool LuaBindState::HasField(int idx, int key) {
+	bool State::HasField(int idx, int key) {
 
 		this->GetField(idx, key);
 		bool hasField = (lua_isnil(mState, -1) == false);
@@ -271,7 +271,7 @@ namespace LuaBind
 		return hasField;
 	}
 
-	bool LuaBindState::HasField(int idx, cc8* name, int type) {
+	bool State::HasField(int idx, cc8* name, int type) {
 
 		lua_getfield(mState, idx, name);
 		bool hasField = (lua_type(mState, -1) == type);
@@ -280,7 +280,7 @@ namespace LuaBind
 		return hasField;
 	}
 
-	bool LuaBindState::HasField(int idx, int key, int type) {
+	bool State::HasField(int idx, int key, int type) {
 
 		this->GetField(idx, key);
 		bool hasField = (lua_type(mState, -1) == type);
@@ -289,7 +289,7 @@ namespace LuaBind
 		return hasField;
 	}
 
-	bool LuaBindState::HasKeys(int idx) {
+	bool State::HasKeys(int idx) {
 
 		idx = this->AbsIndex(idx);
 
@@ -301,12 +301,12 @@ namespace LuaBind
 		return false;
 	}
 
-	void LuaBindState::GetField(int idx, cc8* name) 
+	void State::GetField(int idx, cc8* name) 
 	{
 		lua_getfield(mState, idx, name);
 	}
 
-	void LuaBindState::GetField(int idx, int key) 
+	void State::GetField(int idx, int key) 
 	{
 		idx = this->AbsIndex(idx);
 
@@ -314,7 +314,7 @@ namespace LuaBind
 		lua_gettable(mState, idx);
 	}
 
-	std::string LuaBindState::GetField(int idx, cc8* key, cc8* default_value) 
+	std::string State::GetField(int idx, cc8* key, cc8* default_value) 
 	{
 		std::string str;
 		if (this->GetFieldWithType(idx, key, LUA_TSTRING)) {
@@ -327,7 +327,7 @@ namespace LuaBind
 		return str;
 	}
 
-	std::string LuaBindState::GetField(int idx, int key, cc8* default_value)
+	std::string State::GetField(int idx, int key, cc8* default_value)
 	{
 		std::string str;
 		if (this->GetFieldWithType(idx, key, LUA_TSTRING)) {
@@ -340,7 +340,7 @@ namespace LuaBind
 		return str;
 	}
 
-	std::string LuaBindState::GetField(int idx, cc8* key, const std::string& value)
+	std::string State::GetField(int idx, cc8* key, const std::string& value)
 	{
 		std::string str;
 		if (this->GetFieldWithType(idx, key, LUA_TSTRING)) {
@@ -353,7 +353,7 @@ namespace LuaBind
 		return str;
 	}
 
-	std::string LuaBindState::GetField(int idx, int key, const std::string& value) 
+	std::string State::GetField(int idx, int key, const std::string& value) 
 	{
 		std::string str;
 		if (this->GetFieldWithType(idx, key, LUA_TSTRING)) {
@@ -366,7 +366,7 @@ namespace LuaBind
 		return str;
 	}
 
-	bool LuaBindState::GetFieldWithType(int idx, cc8* name, int type) 
+	bool State::GetFieldWithType(int idx, cc8* name, int type) 
 	{
 		lua_getfield(mState, idx, name);
 		if (lua_type(mState, -1) != type) {
@@ -376,7 +376,7 @@ namespace LuaBind
 		return true;
 	}
 
-	bool LuaBindState::GetFieldWithType(int idx, int key, int type) 
+	bool State::GetFieldWithType(int idx, int key, int type) 
 	{
 		this->GetField(idx, key);
 		if (lua_type(mState, -1) != type) {
@@ -386,7 +386,7 @@ namespace LuaBind
 		return true;
 	}
 
-	void LuaBindState::SetField(int idx, cc8* key)
+	void State::SetField(int idx, cc8* key)
 	{
 		if (IsTableOrUserdata(idx))
 		{
@@ -395,7 +395,7 @@ namespace LuaBind
 		}
 	}
 
-	cc8* LuaBindState::GetLuaTypeName(int type) 
+	cc8* State::GetLuaTypeName(int type) 
 	{
 		switch (type) {
 			case LUA_TNONE:				return "none";
@@ -413,7 +413,7 @@ namespace LuaBind
 	}
 
 	
-	bool LuaBindState::GetSubfieldWithType(int idx, cc8* format, int type, ...) 
+	bool State::GetSubfieldWithType(int idx, cc8* format, int type, ...) 
 	{
 		va_list args;
 		va_start(args, type);
@@ -449,7 +449,7 @@ namespace LuaBind
 		return true;
 	}
 
-	bool LuaBindState::CheckParams(int idx, cc8* format)
+	bool State::CheckParams(int idx, cc8* format)
 	{
 		idx = AbsIndex(idx);
 
@@ -520,7 +520,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	bool LuaBindState::GetValue < bool >(int idx, const bool value) {
+	bool State::GetValue < bool >(int idx, const bool value) {
 
 		if (this->IsType(idx, LUA_TBOOLEAN)) {
 			return (lua_toboolean(this->mState, idx) != 0);
@@ -530,7 +530,7 @@ namespace LuaBind
 
 	
 	template <>
-	cc8* LuaBindState::GetValue < cc8* >(int idx, const cc8* value) {
+	cc8* State::GetValue < cc8* >(int idx, const cc8* value) {
 
 		if (this->IsType(idx, LUA_TSTRING)) {
 			return lua_tostring(this->mState, idx);
@@ -539,7 +539,7 @@ namespace LuaBind
 	}
 
 	template <>
-	std::string LuaBindState::GetValue<std::string>(int idx, const std::string value) 
+	std::string State::GetValue<std::string>(int idx, const std::string value) 
 	{
 		std::string str;
 		if (lua_type(this->mState, idx) == LUA_TSTRING) {
@@ -552,7 +552,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	double LuaBindState::GetValue < double >(int idx, const double value) 
+	double State::GetValue < double >(int idx, const double value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return lua_tonumber(this->mState, idx);
@@ -561,7 +561,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	float LuaBindState::GetValue < float >(int idx, const float value) 
+	float State::GetValue < float >(int idx, const float value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (float)lua_tonumber(this->mState, idx);
@@ -570,7 +570,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	s8 LuaBindState::GetValue < s8 >(int idx, const s8 value)
+	s8 State::GetValue < s8 >(int idx, const s8 value)
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (s8)lua_tonumber(this->mState, idx);
@@ -580,7 +580,7 @@ namespace LuaBind
 
 	
 	template <>
-	s16 LuaBindState::GetValue < s16 >(int idx, const s16 value) 
+	s16 State::GetValue < s16 >(int idx, const s16 value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (s16)lua_tonumber(this->mState, idx);
@@ -590,7 +590,7 @@ namespace LuaBind
 
 	
 	template <>
-	s32 LuaBindState::GetValue < s32 >(int idx, const s32 value) 
+	s32 State::GetValue < s32 >(int idx, const s32 value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (s32)lua_tonumber(this->mState, idx);
@@ -599,7 +599,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	s64 LuaBindState::GetValue < s64 >(int idx, const s64 value) 
+	s64 State::GetValue < s64 >(int idx, const s64 value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (s64)lua_tonumber(this->mState, idx);
@@ -608,7 +608,7 @@ namespace LuaBind
 	}
 
 	template <>
-	u8 LuaBindState::GetValue < u8 >(int idx, const u8 value) 
+	u8 State::GetValue < u8 >(int idx, const u8 value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (u8)lua_tonumber(this->mState, idx);
@@ -617,7 +617,7 @@ namespace LuaBind
 	}
 
 	template <>
-	u16 LuaBindState::GetValue < u16 >(int idx, const u16 value)
+	u16 State::GetValue < u16 >(int idx, const u16 value)
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (u16)lua_tonumber(this->mState, idx);
@@ -626,7 +626,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	u32 LuaBindState::GetValue < u32 >(int idx, const u32 value) 
+	u32 State::GetValue < u32 >(int idx, const u32 value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (u32)lua_tonumber(this->mState, idx);
@@ -635,7 +635,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	u64 LuaBindState::GetValue < u64 >(int idx, const u64 value) 
+	u64 State::GetValue < u64 >(int idx, const u64 value) 
 	{
 		if (this->IsType(idx, LUA_TNUMBER)) {
 			return (u64)lua_tonumber(this->mState, idx);
@@ -644,7 +644,7 @@ namespace LuaBind
 	}
 	
 	template <>
-	const void* LuaBindState::GetValue < const void* >(int idx, const void* value)
+	const void* State::GetValue < const void* >(int idx, const void* value)
 	{
 		if (this->IsType(idx, LUA_TLIGHTUSERDATA)) {
 			return (void*)lua_touserdata(this->mState, idx);
@@ -652,14 +652,14 @@ namespace LuaBind
 		return value;
 	}
 
-	void LuaBindState::PushPtrUserdata(void* ptr) 
+	void State::PushPtrUserdata(void* ptr) 
 	{
 		void** handle = (void**)lua_newuserdata(this->mState, sizeof(void*));
 		assert(handle);
 		(*handle) = ptr;
 	}
 
-	void LuaBindState::RegisterEnum(cc8* name, LuaBindEnum* en)
+	void State::RegisterEnum(cc8* name, Enum* en)
 	{
 		assert(name);
 		assert(en);
@@ -699,21 +699,21 @@ namespace LuaBind
 	}
 
 
-	void LuaBindState::RegisterMethods(const luaL_Reg *l)
+	void State::RegisterMethods(const luaL_Reg *l)
 	{
 		assert(lua_istable(mState, -1));
 		// luaL_register第二个参数为空，则向-1位置注册luaL_Reg中这些函数
 		luaL_register(mState, 0, l);
 	}
 
-	void LuaBindState::RegisterMethod(cc8* fname, lua_CFunction func)
+	void State::RegisterMethod(cc8* fname, lua_CFunction func)
 	{
 		assert(lua_istable(mState, -1));
 		lua_pushcfunction(mState, func);
 		lua_setfield(mState, -1, fname);
 	}
 
-	void LuaBindState::RegisterPreloader(cc8* libname, lua_CFunction preloader)
+	void State::RegisterPreloader(cc8* libname, lua_CFunction preloader)
 	{
 		lua_getglobal(mState, "package");
 		lua_getfield(mState, -1, "preload");
@@ -722,36 +722,36 @@ namespace LuaBind
 		lua_pop(mState, 2);
 	}
 
-	void LuaBindState::RegisterLib(cc8* libname, const luaL_Reg* l)
+	void State::RegisterLib(cc8* libname, const luaL_Reg* l)
 	{
 		luaL_register(mState, libname, l);
 	}
 
 #if LUA_BIND_ENABLE_PLAIN_CLASS
-	void LuaBindState::RegisterPlainClassRegistry(cc8* name)
+	void State::RegisterPlainClassRegistry(cc8* name)
 	{
 		assert(lua_istable(mState, -1));
-		lua_pushcfunction(mState, LuaBindPlainClass::registry);
+		lua_pushcfunction(mState, PlainClass::registry);
 		lua_setfield(mState, -2, name);
 	}
 #endif
 
 #if LUA_BIND_ENABLE_PLAIN_ENUM
-	void LuaBindState::RegisterPlainEnumRegistry(cc8* name)
+	void State::RegisterPlainEnumRegistry(cc8* name)
 	{
 		assert(lua_istable(mState, -1));
-		lua_pushcfunction(mState, LuaBindPlainEnum::registry);
+		lua_pushcfunction(mState, PlainEnum::registry);
 		lua_setfield(mState, -2, name);
 	}
 #endif
 
-	int LuaBindState::ErrorType(int idx, cc8* hint)
+	int State::ErrorType(int idx, cc8* hint)
 	{
 		return luaL_typerror(mState, idx, hint);
 	}
 
 	template <> 
-	bool LuaBindState::CheckValue < bool >(int idx)
+	bool State::CheckValue < bool >(int idx)
 	{
 		bool b = false;
 		if (lua_type(mState, idx) == LUA_TBOOLEAN)
@@ -766,73 +766,73 @@ namespace LuaBind
 	}
 
 	template <> 
-	cc8* LuaBindState::CheckValue < cc8* >(int idx)
+	cc8* State::CheckValue < cc8* >(int idx)
 	{
 		return luaL_checkstring(mState, idx);
 	}
 
 	template <> 
-	double LuaBindState::CheckValue < double >(int idx)
+	double State::CheckValue < double >(int idx)
 	{
 		return luaL_checknumber(mState, idx);
 	}
 
 	template <> 
-	float LuaBindState::CheckValue < float >(int idx)
+	float State::CheckValue < float >(int idx)
 	{
 		return luaL_checknumber(mState, idx);
 	}
 
 	template <> 
-	s8 LuaBindState::CheckValue < s8 >(int idx)
+	s8 State::CheckValue < s8 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	s16 LuaBindState::CheckValue < s16 >(int idx)
+	s16 State::CheckValue < s16 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	s32 LuaBindState::CheckValue < s32 >(int idx)
+	s32 State::CheckValue < s32 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	s64 LuaBindState::CheckValue < s64 >(int idx)
+	s64 State::CheckValue < s64 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	u8 LuaBindState::CheckValue < u8 >(int idx)
+	u8 State::CheckValue < u8 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	u16 LuaBindState::CheckValue < u16 >(int idx)
+	u16 State::CheckValue < u16 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	u32 LuaBindState::CheckValue < u32 >(int idx)
+	u32 State::CheckValue < u32 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	u64	 LuaBindState::CheckValue < u64 >(int idx)
+	u64	 State::CheckValue < u64 >(int idx)
 	{
 		return luaL_checkinteger(mState, idx);
 	}
 
 	template <> 
-	std::string LuaBindState::CheckValue < std::string >(int idx)
+	std::string State::CheckValue < std::string >(int idx)
 	{
 		return luaL_checkstring(mState, idx);
 	}
@@ -841,7 +841,7 @@ namespace LuaBind
 	/// check light userdata
 	///
 	template <>
-	const void* LuaBindState::CheckValue < const void* >(int idx)
+	const void* State::CheckValue < const void* >(int idx)
 	{
 		if (IsType(idx, LUA_TLIGHTUSERDATA))
 		{
diff --git a/Runtime/Scripting/LuaBindState.h b/Runtime/Scripting/LuaBindState.h
index 76357cf..ea8cf5b 100644
--- a/Runtime/Scripting/LuaBindState.h
+++ b/Runtime/Scripting/LuaBindState.h
@@ -7,13 +7,13 @@
 #include "LuaBindRefTable.h"
 #include "LuaBindGlobalState.h"
 
-namespace LuaBind 
+namespace LuaBind
 {
 
-	class LuaBindVM;
-	class LuaBindEnum;
-	class LuaBindStrongRef;
-	class LuaBindWeakRef;
+	class VM;
+	class Enum;
+	class StrongRef;
+	class WeakRef;
 
 	///
 	/// 对lua_State的代理，除了保存一个lua_State的引用不保存其他内容。一个实例的metatable如下：
@@ -24,13 +24,13 @@ namespace LuaBind
 	/// 从userdata通过getmetatable获取上级metatable。除此之外还有一个class table注册在对应
 	/// 的名称空间里。
 	///
-	LUA_BIND_API class LuaBindState 
+	LUA_BIND_API class State 
 	{
 	public:
 
-		LuaBindState(lua_State* state);
-		LuaBindState(const LuaBindState& state);
-		virtual ~LuaBindState();
+		State(lua_State* state);
+		State(const State& state);
+		virtual ~State();
 
 		inline lua_State* operator ->() { return mState; };
 		inline lua_State& operator *() { return *mState; };
@@ -44,7 +44,7 @@ namespace LuaBind
 
 		global_State* GetGlobalState();
 
-		LuaBindVM* GetVM();
+		VM* GetVM();
 
 		//------------------------------------------------------------------------------//
 
@@ -163,7 +163,7 @@ namespace LuaBind
 		///
 		/// 注册枚举
 		///
-		void RegisterEnum(cc8* name, LuaBindEnum* enums);
+		void RegisterEnum(cc8* name, Enum* enums);
 
 		///
 		/// 注册C函数，注意后面加一行{0， 0}
@@ -203,10 +203,10 @@ namespace LuaBind
 
 	protected:
 
-		friend class LuaBindVM;
+		friend class VM;
 
 		///
-		/// 屏蔽对LuaBindState的地址相关操作
+		/// 屏蔽对State的地址相关操作
 		///
 		void* operator &();
 		void* operator new(size_t size);
@@ -217,69 +217,69 @@ namespace LuaBind
 	//--------------------------------------------------------------------------------//
 	// GetValue()模板特化
 
-	template <> bool LuaBindState::GetValue < bool >(int idx, const bool value);
-	template <> cc8* LuaBindState::GetValue < cc8* >(int idx, const cc8* value);
-	template <> double LuaBindState::GetValue < double >(int idx, const double value);
-	template <> float LuaBindState::GetValue < float >(int idx, const float value);
-	template <> s8 LuaBindState::GetValue < s8 >(int idx, const s8 value);
-	template <> s16 LuaBindState::GetValue < s16 >(int idx, const s16 value);
-	template <> s32 LuaBindState::GetValue < s32 >(int idx, const s32 value);
-	template <> s64 LuaBindState::GetValue < s64 >(int idx, const s64 value);
-	template <> u8 LuaBindState::GetValue < u8 >(int idx, const u8 value);
-	template <> u16 LuaBindState::GetValue < u16 >(int idx, const u16 value);
-	template <> u32 LuaBindState::GetValue < u32 >(int idx, const u32 value);
-	template <> u64	 LuaBindState::GetValue < u64 >(int idx, const u64 value);
-	template <> std::string LuaBindState::GetValue < std::string >(int idx, const std::string value);
-	template <> const void* LuaBindState::GetValue < const void* >(int idx, const void* value);
+	template <> bool State::GetValue < bool >(int idx, const bool value);
+	template <> cc8* State::GetValue < cc8* >(int idx, const cc8* value);
+	template <> double State::GetValue < double >(int idx, const double value);
+	template <> float State::GetValue < float >(int idx, const float value);
+	template <> s8 State::GetValue < s8 >(int idx, const s8 value);
+	template <> s16 State::GetValue < s16 >(int idx, const s16 value);
+	template <> s32 State::GetValue < s32 >(int idx, const s32 value);
+	template <> s64 State::GetValue < s64 >(int idx, const s64 value);
+	template <> u8 State::GetValue < u8 >(int idx, const u8 value);
+	template <> u16 State::GetValue < u16 >(int idx, const u16 value);
+	template <> u32 State::GetValue < u32 >(int idx, const u32 value);
+	template <> u64	 State::GetValue < u64 >(int idx, const u64 value);
+	template <> std::string State::GetValue < std::string >(int idx, const std::string value);
+	template <> const void* State::GetValue < const void* >(int idx, const void* value);
 
 	//--------------------------------------------------------------------------------//
 	// CheckValue模板特化
 
-	template <> bool LuaBindState::CheckValue < bool >(int idx);
-	template <> cc8* LuaBindState::CheckValue < cc8* >(int idx);
-	template <> double LuaBindState::CheckValue < double >(int idx);
-	template <> float LuaBindState::CheckValue < float >(int idx);
-	template <> s8 LuaBindState::CheckValue < s8 >(int idx);
-	template <> s16 LuaBindState::CheckValue < s16 >(int idx);
-	template <> s32 LuaBindState::CheckValue < s32 >(int idx);
-	template <> s64 LuaBindState::CheckValue < s64 >(int idx);
-	template <> u8 LuaBindState::CheckValue < u8 >(int idx);
-	template <> u16 LuaBindState::CheckValue < u16 >(int idx);
-	template <> u32 LuaBindState::CheckValue < u32 >(int idx);
-	template <> u64	 LuaBindState::CheckValue < u64 >(int idx);
-	template <> std::string LuaBindState::CheckValue < std::string >(int idx);
-	template <> const void* LuaBindState::CheckValue < const void* >(int idx);
+	template <> bool State::CheckValue < bool >(int idx);
+	template <> cc8* State::CheckValue < cc8* >(int idx);
+	template <> double State::CheckValue < double >(int idx);
+	template <> float State::CheckValue < float >(int idx);
+	template <> s8 State::CheckValue < s8 >(int idx);
+	template <> s16 State::CheckValue < s16 >(int idx);
+	template <> s32 State::CheckValue < s32 >(int idx);
+	template <> s64 State::CheckValue < s64 >(int idx);
+	template <> u8 State::CheckValue < u8 >(int idx);
+	template <> u16 State::CheckValue < u16 >(int idx);
+	template <> u32 State::CheckValue < u32 >(int idx);
+	template <> u64	 State::CheckValue < u64 >(int idx);
+	template <> std::string State::CheckValue < std::string >(int idx);
+	template <> const void* State::CheckValue < const void* >(int idx);
 
 	///
-	/// 在成员方法里创建LuaBindState并对参数进行检查。
+	/// 在成员方法里创建State并对参数进行检查。
 	///
 #define LUA_BIND_SETUP(L, params) \
-	LuaBind::LuaBindState state(L); \
+	LuaBind::State state(L); \
 	if(!state.CheckParams(1, params)) return 0
 
 #define LUA_BIND_STATE(L) \
-	LuaBind::LuaBindState state(L)
+	LuaBind::State state(L)
 
 	//--------------------------------------------------------------------------------//
 
 	///
 	/// 确保不安全的lua调用能够在调用之后返回到最初stack状态。
 	///
-	class LuaBindScopedState
-		: public LuaBindState
+	class ScopedState
+		: public State
 	{
 	public:
-		LuaBindScopedState(lua_State* state)
-			: LuaBindState(state)
+		ScopedState(lua_State* state)
+			: State(state)
 		{
 			mRestoreTop = lua_gettop(mState);
 		}
-		LuaBindScopedState(const LuaBindState& state)
-			: LuaBindState(state)
+		ScopedState(const State& state)
+			: State(state)
 		{
 			mRestoreTop = lua_gettop(mState);
 		}
-		~LuaBindScopedState()
+		~ScopedState()
 		{
 			if (mState) {
 				if (lua_gettop(mState) != mRestoreTop) {
diff --git a/Runtime/Scripting/LuaBindState.inc b/Runtime/Scripting/LuaBindState.inc
index b2692cb..27151ff 100644
--- a/Runtime/Scripting/LuaBindState.inc
+++ b/Runtime/Scripting/LuaBindState.inc
@@ -5,21 +5,21 @@ namespace LuaBind
 	/// 注册工厂，注册class table，以type name为键设置在名称空间上。在注册阶段不会设置元表，等到New方法调用的时候才会。
 	/// 
 	template<class TYPE>
-	void LuaBindState::RegisterFactory()
+	void State::RegisterFactory()
 	{
-		cc8* type = TYPE::GetLuaBindFactoryName();
+		cc8* type = TYPE::GetFactoryName();
 
 		lua_State* L = mState;
-		LuaBindState& state = *this;
+		State& state = *this;
 
 		int top = lua_gettop(L); // namespace table
 		assert(lua_istable(L, top));
 
 		// class table
 		lua_newtable(L);
-		TYPE::RegisterLuaBindClassShared(state);
-		TYPE::RegisterLuaBindFactoryClass(state);
-		TYPE::RegisterLuaBindClass(state);
+		TYPE::RegisterClassShared(state);
+		TYPE::RegisterFactoryClass(state);
+		TYPE::RegisterClass(state);
 
 		// 检测TYPE里面是否没有注册必须的方法
 #define _assertmethod(I, NAME) \
@@ -42,7 +42,7 @@ namespace LuaBind
 		lua_pushvalue(state, -1); // class table
 		lua_setfield(state, -2, "__index");
 
-		TYPE::SetLuaBindClassTableRef(state, -1);
+		TYPE::SetClassTableRef(state, -1);
 
 		SetField(top, type);
 
@@ -50,28 +50,28 @@ namespace LuaBind
 		lua_settop(L, top);
 
 		// 后处理
-		TYPE::RegisterLuaBindPostprocess(state);
+		TYPE::RegisterPostprocess(state);
 	}
 
 	///
 	/// Singleton
 	///
 	template<typename TYPE>
-	void LuaBindState::RegisterSingleton()
+	void State::RegisterSingleton()
 	{
 		lua_State* L = mState;
-		LuaBindState& state = *this;
+		State& state = *this;
 
 		int top = lua_gettop(L); // namespace table
 		assert(lua_istable(L, top));
 
 		// class table.
 		lua_newtable(L);
-		TYPE::RegisterLuaBindClassShared(state);
-		TYPE::RegisterLuaBindSingletonClass(state);
-		TYPE::RegisterLuaBindClass(state);
+		TYPE::RegisterClassShared(state);
+		TYPE::RegisterSingletonClass(state);
+		TYPE::RegisterClass(state);
 
-		TYPE::SetLuaBindClassTableRef(state, -1);
+		TYPE::SetClassTableRef(state, -1);
 
 		lua_pushvalue(state, -1);
 		lua_setfield(state, -2, "__index");
@@ -83,18 +83,18 @@ namespace LuaBind
 		lua_setfield(state, -2, "Extend");
 #endif
 
-		cc8* type = TYPE::GetLuaBindSingletonName();
+		cc8* type = TYPE::GetSingletonName();
 		SetField(top, type);
 
 		// reset top
 		lua_settop(L, top);
 
 		// 后处理
-		TYPE::RegisterLuaBindPostprocess(state);
+		TYPE::RegisterPostprocess(state);
 	}
 
 	template<typename TYPE>
-	void LuaBindState::SetField(int idx, cc8* key, TYPE value)
+	void State::SetField(int idx, cc8* key, TYPE value)
 	{
 		if (IsTableOrUserdata(idx))
 		{
@@ -105,7 +105,7 @@ namespace LuaBind
 	}
 
 	template<typename TYPE> 
-	void LuaBindState::SetFieldByIndex(int idx, int key, TYPE value)
+	void State::SetFieldByIndex(int idx, int key, TYPE value)
 	{
 		if (IsTableOrUserdata(idx))
 		{
@@ -116,7 +116,7 @@ namespace LuaBind
 	}
 
 	template<typename TYPE>
-	TYPE LuaBindState::GetField(int idx, cc8* key, TYPE value)
+	TYPE State::GetField(int idx, cc8* key, TYPE value)
 	{
 		GetField(idx, key);
 		TYPE result = GetValue < TYPE >(-1, value);
@@ -126,7 +126,7 @@ namespace LuaBind
 	}
 
 	template<typename TYPE>
-	TYPE LuaBindState::GetField(int idx, int key, TYPE value)
+	TYPE State::GetField(int idx, int key, TYPE value)
 	{
 		GetField(idx, key);
 		TYPE result = GetValue < TYPE >(-1, value);
@@ -136,7 +136,7 @@ namespace LuaBind
 	}
 
 	template<typename TYPE>
-	TYPE* LuaBindState::GetUserdata(int idx)
+	TYPE* State::GetUserdata(int idx)
 	{
 		void* p = nullptr;
 
@@ -149,7 +149,7 @@ namespace LuaBind
 	}
 
 	template<typename TYPE> 
-	TYPE* LuaBindState::CheckUserdata(int idx)
+	TYPE* State::CheckUserdata(int idx)
 	{
 		if (IsType(idx, LUA_TUSERDATA))
 		{
@@ -159,7 +159,7 @@ namespace LuaBind
 				{
 					if (lua_getmetatable(mState, -1)) // class table 
 					{
-						TYPE::PushLuaBindClassTable(*this); // target class table
+						TYPE::PushClassTable(*this); // target class table
 						if (lua_rawequal(mState, -1, -2))
 						{
 							Pop(4); // ref\member\class\target class
@@ -173,7 +173,7 @@ namespace LuaBind
 				Pop(1); // ref table
 			}
 		}
-		luaL_typerror(mState, idx, TYPE::GetLuaBindClassName());
+		luaL_typerror(mState, idx, TYPE::GetClassName());
 		return nullptr;
 	}
 
diff --git a/Runtime/Scripting/LuaBindUtility.h b/Runtime/Scripting/LuaBindUtility.h
index 0643315..4d3d542 100644
--- a/Runtime/Scripting/LuaBindUtility.h
+++ b/Runtime/Scripting/LuaBindUtility.h
@@ -3,31 +3,31 @@
 
 // 导出native接口
 
-/// RegisterLuaBindClass 注册类的方法和成员，比如枚举、常量等到class table LuaBindGetFactoryName 获得工厂的类名，
+/// RegisterClass 注册类的方法和成员，比如枚举、常量等到class table GetFactoryName 获得工厂的类名，
 /// 同时用来避免注册时错误注册为了singleton，通过编译时报错避免
 #define LUA_BIND_DECL_FACTORY(type, ...) \
-	friend class       LuaBind::LuaBindState; \
-	friend class       LuaBind::LuaBindNativeClass<type,##__VA_ARGS__>; \
-	static void        RegisterLuaBindClass(LuaBind::LuaBindState&); \
-	static void        RegisterLuaBindPostprocess(LuaBind::LuaBindState&); \
-	static const char* GetLuaBindFactoryName() { return #type; };\
-	static const char* GetLuaBindClassName() { return #type; };\
-	static bool        IsLuaBindClassSingleton() { return false; } 
+	friend class       ::State; \
+	friend class       ::NativeClass<type,##__VA_ARGS__>; \
+	static void        RegisterClass(::State&); \
+	static void        RegisterPostprocess(::State&); \
+	static const char* GetFactoryName() { return #type; };\
+	static const char* GetClassName() { return #type; };\
+	static bool        IsClassSingleton() { return false; } 
 
 /// 作为基类的抽象工厂类可以使用此宏，注册一个入口，在派生类的注册函数中调用，注册基类的这些方法。
 #define LUA_BIND_DECL_ABSTRACT_FACTORY() \
-	static void RegisterLuaBindClass(LuaBind::LuaBindState&);\
-	static void RegisterLuaBindPostprocess(LuaBind::LuaBindState&)
+	static void RegisterClass(::State&);\
+	static void RegisterPostprocess(::State&)
 
-/// RegisterLuaBindClass 注册类的方法和成员，比如枚举、常量等到class table LuaBindGetSingletonName 获得单例的类名
+/// RegisterClass 注册类的方法和成员，比如枚举、常量等到class table GetSingletonName 获得单例的类名
 #define LUA_BIND_DECL_SINGLETON(type, ...) \
-	friend class       LuaBind::LuaBindState; \
-	friend class       LuaBind::LuaBindNativeClass<type,##__VA_ARGS__>; \
-	static void        RegisterLuaBindClass(LuaBind::LuaBindState&);  \
-	static void        RegisterLuaBindPostprocess(LuaBind::LuaBindState&); \
-	static const char* GetLuaBindSingletonName() { return #type; }; \
-	static const char* GetLuaBindClassName() { return #type; }; \
-	static bool        IsLuaBindClassSingleton() { return true; }
+	friend class       ::State; \
+	friend class       ::NativeClass<type,##__VA_ARGS__>; \
+	static void        RegisterClass(::State&);  \
+	static void        RegisterPostprocess(::State&); \
+	static const char* GetSingletonName() { return #type; }; \
+	static const char* GetClassName() { return #type; }; \
+	static bool        IsClassSingleton() { return true; }
 
 #define LUA_BIND_DECL_METHOD(mtd) static int mtd(lua_State* L)
 
@@ -37,13 +37,13 @@
 #define LUA_BIND_IMPL_METHOD(type, f) int type::f(lua_State* L)
 
 /// 由应用程序实现的两个接口。上下文里有一个state。
-#define LUA_BIND_REGISTRY(type) void type::RegisterLuaBindClass(LuaBind::LuaBindState& state)
-#define LUA_BIND_POSTPROCESS(type) void type::RegisterLuaBindPostprocess(LuaBind::LuaBindState& state)
+#define LUA_BIND_REGISTRY(type) void type::RegisterClass(::State& state)
+#define LUA_BIND_POSTPROCESS(type) void type::RegisterPostprocess(::State& state)
 
 /// 用来注册的宏。之前这里忘了用可变宏，导致没有luaclastable ref没有注册对。
 #define LUA_BIND_REGISTER_FACTORY(state, param) state.RegisterFactory<param>()
 #define LUA_BIND_REGISTER_SINGLETON(state, param) state.RegisterSingleton<param>()
-#define LUA_BIND_REGISTER_ABSTRACT_FACTORY(state, type) type::RegisterLuaBindPostprocess(state)
+#define LUA_BIND_REGISTER_ABSTRACT_FACTORY(state, type) type::RegisterPostprocess(state)
 #define LUA_BIND_REGISTER_METHODS(state, ...) \
 	do{ \
 	luaL_Reg __m[] = {__VA_ARGS__,{0, 0}}; \
@@ -51,7 +51,7 @@
 	}while(0)
 #define LUA_BIND_REGISTER_ENUM(state, name, ...) \
 	do{ \
-	LuaBind::LuaBindEnum __e[] = {__VA_ARGS__,{0, 0}}; \
+	::Enum __e[] = {__VA_ARGS__,{0, 0}}; \
 	state.RegisterEnum(name, __e); \
 	}while(0)
 
@@ -59,7 +59,7 @@
 	LUA_BIND_STATE(L); \
 	T* self = state.GetUserdata<T>(1);
 
-#define LUA_BIND_INHERIT(state, type) type::RegisterLuaBindClass(state)
+#define LUA_BIND_INHERIT(state, type) type::RegisterClass(state)
 
 #define luaxport private
 
diff --git a/Runtime/Scripting/LuaBindVM.cpp b/Runtime/Scripting/LuaBindVM.cpp
index ce68a80..b50a5e1 100644
--- a/Runtime/Scripting/LuaBindVM.cpp
+++ b/Runtime/Scripting/LuaBindVM.cpp
@@ -4,9 +4,9 @@
 namespace LuaBind
 {
 
-	LuaBindVM::VMap LuaBindVM::VMs;   // 通过线程查找虚拟机，为了方便
+	VM::VMap VM::VMs;   // 通过线程查找虚拟机，为了方便
 
-	LuaBindVM* LuaBindVM::TryGetVM(global_State* gState)
+	VM* VM::TryGetVM(global_State* gState)
 	{
 		auto it = VMs.find(gState);
 		if (it != VMs.end())
@@ -15,12 +15,12 @@ namespace LuaBind
 			return nullptr;
 	}
 
-	LuaBindVM* LuaBindVM::TryGetVM(lua_State* state)
+	VM* VM::TryGetVM(lua_State* state)
 	{
 		return TryGetVM(G(state));
 	}
 
-	LuaBindVM::LuaBindVM()
+	VM::VM()
 		: mStrongRefTable()
 		, mWeakRefTable()
 	{
@@ -28,17 +28,17 @@ namespace LuaBind
 		assert(mMainThread);
 		mGlobalState = G(mMainThread);
 
-		VMs.insert(std::pair<global_State*, LuaBindVM*>(mGlobalState, this));
+		VMs.insert(std::pair<global_State*, VM*>(mGlobalState, this));
 	}
 
-	LuaBindVM::~LuaBindVM()
+	VM::~VM()
 	{
 		VMs.erase(mGlobalState);
 		lua_close(mMainThread);
 	}
 
 	// 初始化context 
-	void LuaBindVM::Setup()
+	void VM::Setup()
 	{
 		LUA_BIND_STATE(mMainThread);
 
@@ -46,29 +46,29 @@ namespace LuaBind
 		mWeakRefTable.Init(state, "_LUA_BIND_WEAKREF_TABLE", "v");
 	}
 
-	lua_State* LuaBindVM::CreateThread()
+	lua_State* VM::CreateThread()
 	{
 		lua_State* thread = lua_newthread(mMainThread);
 		assert(thread);
 		return thread;
 	}
 
-	lua_State* LuaBindVM::GetMainThread()
+	lua_State* VM::GetMainThread()
 	{
 		return mMainThread;
 	}
 
-	LuaBindState LuaBindVM::GetMainState()
+	State VM::GetMainState()
 	{
 		return mMainThread;
 	}
 
-	LuaBindRefTable& LuaBindVM::GetStrongRefTable()
+	RefTable& VM::GetStrongRefTable()
 	{
 		return mStrongRefTable;
 	}
 
-	LuaBindRefTable& LuaBindVM::GetWeakRefTable()
+	RefTable& VM::GetWeakRefTable()
 	{
 		return mWeakRefTable;
 	}
diff --git a/Runtime/Scripting/LuaBindVM.h b/Runtime/Scripting/LuaBindVM.h
index dcff44f..287f906 100644
--- a/Runtime/Scripting/LuaBindVM.h
+++ b/Runtime/Scripting/LuaBindVM.h
@@ -15,18 +15,18 @@ namespace LuaBind
 	///
 	/// 单个lua_state相关的context。是一系列代理的集合，拷贝也没关系，主要是为了节约内存。
 	///
-	class LuaBindVM
+	class VM
 	{
 	public:
 
 		///
 		/// 根据global_State拿到虚拟机。
 		///
-		static LuaBindVM* TryGetVM(global_State* gState);
-		static LuaBindVM* TryGetVM(lua_State* state);
+		static VM* TryGetVM(global_State* gState);
+		static VM* TryGetVM(lua_State* state);
 
-		LuaBindVM();
-		~LuaBindVM();
+		VM();
+		~VM();
 
 		///
 		/// 创建虚拟机后，需要手动调用Setup函数，初始化一些虚拟机状态。
@@ -35,19 +35,19 @@ namespace LuaBind
 
 		lua_State* GetMainThread();
 		lua_State* CreateThread();
-		LuaBindState GetMainState();
+		State GetMainState();
 
-		LuaBindRefTable& GetStrongRefTable();
-		LuaBindRefTable& GetWeakRefTable();
+		RefTable& GetStrongRefTable();
+		RefTable& GetWeakRefTable();
 
 	private:
 
-		typedef std::map<global_State*, LuaBindVM*> VMap;
+		typedef std::map<global_State*, VM*> VMap;
 
 		static VMap VMs;               // 通过global_State索引虚拟机，为了方便
 
-		LuaBindRefTable  mStrongRefTable; // _LUA_BIND_STRONGREF_TABLE
-		LuaBindRefTable  mWeakRefTable;   // _LUA_BIND_WEAKREF_TABLE
+		RefTable  mStrongRefTable; // _LUA_BIND_STRONGREF_TABLE
+		RefTable  mWeakRefTable;   // _LUA_BIND_WEAKREF_TABLE
 
 		global_State* mGlobalState;    // 虚拟机的global_State，由当前虚拟机的所有线程共享
 		lua_State*    mMainThread;     // 主线程
diff --git a/Runtime/Scripting/LuaBindWatchDog.h b/Runtime/Scripting/LuaBindWatchDog.h
index f8b32cb..44d1d35 100644
--- a/Runtime/Scripting/LuaBindWatchDog.h
+++ b/Runtime/Scripting/LuaBindWatchDog.h
@@ -7,12 +7,12 @@ namespace LuaBind
 {
 
 	///
-	/// LuaBindNativeClass实例的引用计数额watch dog，只有在watch dog通过时才可以delete。
+	/// NativeClass实例的引用计数额watch dog，只有在watch dog通过时才可以delete。
 	///
-	class LuaBindWatchDog
+	class WatchDog
 	{
 	public: 
-		LuaBindWatchDog()
+		WatchDog()
 			: mVMRef(0)
 			, mNativeRef(0)
 		{