*修改成员变量前缀

13 files changed, 195 insertions, 195 deletions

diff --git a/source/modules/asura-utils/threading/binding/_thread.cpp b/source/modules/asura-utils/threading/binding/_thread.cpp
index ad2fb7f..ae43242 100644
--- a/source/modules/asura-utils/threading/binding/_thread.cpp
+++ b/source/modules/asura-utils/threading/binding/_thread.cpp
@@ -185,7 +185,7 @@ namespace AsuraEngine
 		LUAX_IMPL_METHOD(Thread, _GetType)
 		{
 			LUAX_PREPARE(L, Thread);
-			state.Push(self->mType);
+			state.Push(self->m_Type);
 			return 1;
 		}
 
@@ -193,7 +193,7 @@ namespace AsuraEngine
 		LUAX_IMPL_METHOD(Thread, _GetState)
 		{
 			LUAX_PREPARE(L, Thread);
-			state.Push(self->mState);
+			state.Push(self->m_State);
 			return 1;
 		}
 
diff --git a/source/modules/asura-utils/threading/conditional.cpp b/source/modules/asura-utils/threading/conditional.cpp
index eb26e82..e49bfde 100644
--- a/source/modules/asura-utils/threading/conditional.cpp
+++ b/source/modules/asura-utils/threading/conditional.cpp
@@ -6,8 +6,8 @@ namespace AsuraEngine
 	{
 
 		Conditional::Conditional()
-			: mWaiting(0)
-			, mSignals(0)
+			: m_Waiting(0)
+			, m_Signals(0)
 		{
 		}
 
@@ -17,38 +17,38 @@ namespace AsuraEngine
 
 		void Conditional::Signal()
 		{
-			mMutex.Lock(); 
-			if (mWaiting > mSignals)
+		 m_Mutex.Lock(); 
+			if (m_Waiting > m_Signals)
 			{
-				++mSignals;
-				signal(mWaitSem);
-				mMutex.Unlock(); 
-				wait(mDoneSem);
+				++m_Signals;
+				signal(m_WaitSem);
+			 m_Mutex.Unlock(); 
+				wait(m_DoneSem);
 			}
 			else
 			{
-				mMutex.Unlock();
+			 m_Mutex.Unlock();
 			}
 		}
 
 		void Conditional::Broadcast()
 		{
-			mMutex.Lock();
-			if (mWaiting> mSignals) {
+		 m_Mutex.Lock();
+			if (m_Waiting> m_Signals) {
 				int i, num_waiting;
 
-				num_waiting = (mWaiting - mSignals);
-				mSignals = mWaiting;
+				num_waiting = (m_Waiting - m_Signals);
+			 m_Signals = m_Waiting;
 				for (i = 0; i < num_waiting; ++i) {
-					signal(mWaitSem);
+					signal(m_WaitSem);
 				}
-				mMutex.Unlock();
+			 m_Mutex.Unlock();
 				for (i = 0; i < num_waiting; ++i) {
-					wait(mDoneSem);
+					wait(m_DoneSem);
 				}
 			}
 			else {
-				mMutex.Unlock();
+			 m_Mutex.Unlock();
 			}
 
 		}
@@ -57,27 +57,27 @@ namespace AsuraEngine
 		{
 			bool retval;
 
-			mMutex.Lock();
-			++mWaiting;
-			mMutex.Unlock();
+		 m_Mutex.Lock();
+			++m_Waiting;
+		 m_Mutex.Unlock();
 
 			mutex->Unlock();
 
-			retval = wait(mWaitSem, timeout);
+			retval = wait(m_WaitSem, timeout);
 
-			mMutex.Lock();
-			if (mSignals > 0) {
+		 m_Mutex.Lock();
+			if (m_Signals > 0) {
 				if (!retval) {
-					wait(mWaitSem);
+					wait(m_WaitSem);
 				}
-				signal(mDoneSem);
+				signal(m_DoneSem);
 
-				--mSignals;
+				--m_Signals;
 			}
-			--mWaiting;
-			mMutex.Unlock();
+			--m_Waiting;
+		 m_Mutex.Unlock();
 
-			mMutex.Lock();
+		 m_Mutex.Lock();
 
 			return retval;
 		}
diff --git a/source/modules/asura-utils/threading/conditional.h b/source/modules/asura-utils/threading/conditional.h
index 2f9633e..3aee392 100644
--- a/source/modules/asura-utils/threading/conditional.h
+++ b/source/modules/asura-utils/threading/conditional.h
@@ -25,13 +25,13 @@ namespace AsuraEngine
 
 		private:
 
-			Mutex mMutex; 
+			Mutex m_Mutex; 
 
-			Semaphore mWaitSem;
-			Semaphore mDoneSem; 
+			Semaphore m_WaitSem;
+			Semaphore m_DoneSem; 
 
-			int mWaiting; 
-			int mSignals;
+			int m_Waiting; 
+			int m_Signals;
 
 		};
 
diff --git a/source/modules/asura-utils/threading/coroutine.h b/source/modules/asura-utils/threading/coroutine.h
index 01af654..bd0f922 100644
--- a/source/modules/asura-utils/threading/coroutine.h
+++ b/source/modules/asura-utils/threading/coroutine.h
@@ -25,7 +25,7 @@ namespace AsuraEngine
 			///
 			/// ��ǰЭ�̵�state
 			///
-			lua_State* mThreadState;
+			lua_State* m_ThreadState;
 
 			LUAX_DECL_METHOD(_New);
 			LUAX_DECL_METHOD(_Run);
diff --git a/source/modules/asura-utils/threading/mutex.cpp b/source/modules/asura-utils/threading/mutex.cpp
index bd7d419..a36af1b 100644
--- a/source/modules/asura-utils/threading/mutex.cpp
+++ b/source/modules/asura-utils/threading/mutex.cpp
@@ -8,20 +8,20 @@ namespace AsuraEngine
 	{
 
 #define try_create_mutex(impl)\
-	if (!mImpl)						  \
+	if (!m_Impl)						  \
 	{											  \
 		try									  \
 		{										  \
-			mImpl = new impl(); \
+		 m_Impl = new impl(); \
 		}										  \
 		catch (Exception& e)  \
 		{										  \
-			mImpl = nullptr;	  \
+		 m_Impl = nullptr;	  \
 		}										  \
 	}											 
 
 		Mutex::Mutex()
-			: mImpl(nullptr)
+			: m_Impl(nullptr)
 		{
 #if ASURA_MUTEX_WIN32_CRITICLE_SECTION
 			try_create_mutex(MutexImplWin32_CS);
@@ -29,49 +29,49 @@ namespace AsuraEngine
 #if ASURA_MUTEX_WIN32_KERNAL_MUTEX
 			try_create_mutex(MutexImplWin32_KM);
 #endif
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 		}
 
 		Mutex::~Mutex()
 		{
-			if(mImpl)
-				delete mImpl;
+			if(m_Impl)
+				delete m_Impl;
 		}
 
 		void Mutex::Lock()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			mImpl->Lock();
+		 m_Impl->Lock();
 		}
 
 		void Mutex::Unlock()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			mImpl->Unlock();
+		 m_Impl->Unlock();
 		}
 
 #if ASURA_MUTEX_WIN32_CRITICLE_SECTION 
 
 		MutexImplWin32_CS::MutexImplWin32_CS()
 		{
-			::InitializeCriticalSection(&mMutex);
+			::InitializeCriticalSection(&m_Mutex);
 		}
 
 		MutexImplWin32_CS::~MutexImplWin32_CS()
 		{
-			::DeleteCriticalSection(&mMutex);
+			::DeleteCriticalSection(&m_Mutex);
 		}
 
 		void MutexImplWin32_CS::Lock()
 		{
-			::EnterCriticalSection(&mMutex);
+			::EnterCriticalSection(&m_Mutex);
 		}
 
 		void MutexImplWin32_CS::Unlock()
 		{
-			::LeaveCriticalSection(&mMutex);
+			::LeaveCriticalSection(&m_Mutex);
 		}
 
 #endif // ASURA_MUTEX_WIN32_CRITICLE_SECTION
@@ -80,25 +80,25 @@ namespace AsuraEngine
 
 		MutexImplWin32_KM::MutexImplWin32_KM()
 		{
-			mHandle = ::CreateMutex(NULL, FALSE, NULL);
-			if (!mHandle)
+		 m_Handle = ::CreateMutex(NULL, FALSE, NULL);
+			if (!m_Handle)
 				throw Exception("Cant use win32 mutex.");
 		}
 
 		MutexImplWin32_KM::~MutexImplWin32_KM()
 		{
-			::CloseHandle(mHandle);
-			mHandle = NULL;
+			::CloseHandle(m_Handle);
+		 m_Handle = NULL;
 		}
 
 		void MutexImplWin32_KM::Lock()
 		{
-			::WaitForSingleObject(mHandle, ASURA_MUTEX_MAXWAIT);
+			::WaitForSingleObject(m_Handle, ASURA_MUTEX_MAXWAIT);
 		}
 
 		void MutexImplWin32_KM::Unlock()
 		{
-			::ReleaseMutex(mHandle);
+			::ReleaseMutex(m_Handle);
 		}
 
 #endif // ASURA_MUTEX_WIN32_KERNAL_MUTEX
diff --git a/source/modules/asura-utils/threading/mutex.h b/source/modules/asura-utils/threading/mutex.h
index 5d33be1..9e9d2c2 100644
--- a/source/modules/asura-utils/threading/mutex.h
+++ b/source/modules/asura-utils/threading/mutex.h
@@ -34,7 +34,7 @@ namespace AsuraEngine
 			Mutex(const Mutex&);
 			Mutex& operator=(const Mutex&);
 
-			MutexImpl* mImpl;
+			MutexImpl* m_Impl;
 
 		};
 
@@ -86,8 +86,8 @@ namespace AsuraEngine
 
 		private:
 
-			//HANDLE mHandle;
-			CRITICAL_SECTION mMutex;
+			//HANDLE m_Handle;
+			CRITICAL_SECTION m_Mutex;
 
 		};
 
@@ -107,7 +107,7 @@ namespace AsuraEngine
 
 		private:
 
-			HANDLE mHandle;
+			HANDLE m_Handle;
 
 		};
 
diff --git a/source/modules/asura-utils/threading/semaphore.cpp b/source/modules/asura-utils/threading/semaphore.cpp
index aa5d9dd..7e5ccf5 100644
--- a/source/modules/asura-utils/threading/semaphore.cpp
+++ b/source/modules/asura-utils/threading/semaphore.cpp
@@ -10,42 +10,42 @@ namespace AsuraEngine
 	{
 
 #define try_create_semaphore(impl) \
-		if (!mImpl)												\
+		if (!m_Impl)												\
 		{																	\
 			try															\
 			{																\
-				mImpl = new impl(init_count);	\
+			 m_Impl = new impl(init_count);	\
 			}																\
 			catch (Exception& e)						\
 			{																\
-				mImpl = nullptr;							\
+			 m_Impl = nullptr;							\
 			}																\
 		}
 
 		Semaphore::Semaphore(unsigned int init_count)
-			: mImpl(nullptr)
+			: m_Impl(nullptr)
 		{
 #ifdef ASURA_THREAD_WIN32 
 			try_create_semaphore(SemaphoreWin32);
 #endif
-			//ASSERT(mImpl);
+			//ASSERT(m_Impl);
 		}
 
 		Semaphore::~Semaphore()
 		{
-			if (mImpl) delete mImpl;
+			if (m_Impl) delete m_Impl;
 		}
 
 		void Semaphore::Signal()
 		{
-			ASSERT(mImpl);
-			mImpl->Signal();
+			ASSERT(m_Impl);
+		 m_Impl->Signal();
 		}
 
 		bool Semaphore::Wait(int timeout /*= ASURA_MUTEX_MAXWAIT*/)
 		{
-			ASSERT(mImpl);
-			return mImpl->Wait(timeout);
+			ASSERT(m_Impl);
+			return m_Impl->Wait(timeout);
 		}
 
 #if ASURA_THREAD_WIN32 
@@ -54,8 +54,8 @@ namespace AsuraEngine
 			: SemaphoreImpl(init_value)
 		{
 			// UINT_MAX get error.
-			mSem = CreateSemaphore(NULL, init_value, INT_MAX, NULL);
-			if (!mSem)
+		 m_Sem = CreateSemaphore(NULL, init_value, INT_MAX, NULL);
+			if (!m_Sem)
 			{
 				int errorCode = GetLastError();
 				throw Exception("Cant use win32 semaphore. Error code: %d.", errorCode);
@@ -64,23 +64,23 @@ namespace AsuraEngine
 
 		SemaphoreWin32::~SemaphoreWin32()
 		{
-			CloseHandle(mSem);
+			CloseHandle(m_Sem);
 		}
 
 		void SemaphoreWin32::Signal()
 		{
-			InterlockedIncrement(&mCount);
-			if (ReleaseSemaphore(mSem, 1, NULL) == FALSE)
-				InterlockedDecrement(&mCount);
+			InterlockedIncrement(&m_Count);
+			if (ReleaseSemaphore(m_Sem, 1, NULL) == FALSE)
+				InterlockedDecrement(&m_Count);
 		}
 
 		bool SemaphoreWin32::Wait(int timeout)
 		{
 			int result;
-			result = WaitForSingleObject(mSem, timeout);
+			result = WaitForSingleObject(m_Sem, timeout);
 			if (result == WAIT_OBJECT_0)
 			{
-				InterlockedDecrement(&mCount);
+				InterlockedDecrement(&m_Count);
 				return true;
 			}
 			else if(result == WAIT_TIMEOUT)
diff --git a/source/modules/asura-utils/threading/semaphore.h b/source/modules/asura-utils/threading/semaphore.h
index 1a4e3b7..c75ae8a 100644
--- a/source/modules/asura-utils/threading/semaphore.h
+++ b/source/modules/asura-utils/threading/semaphore.h
@@ -28,22 +28,22 @@ namespace AsuraEngine
 			bool Wait(int timeout = ASURA_MUTEX_MAXWAIT);
 
 		private: 
-			SemaphoreImpl* mImpl;
+			SemaphoreImpl* m_Impl;
 		};
 
 		class SemaphoreImpl
 		{
 		public:
 			SemaphoreImpl(unsigned int init_value) 
-				: mCount(init_value)
+				: m_Count(init_value)
 			{
 			};
 			virtual ~SemaphoreImpl() {};
 			virtual void Signal() = 0;
 			virtual bool Wait(int timeout) = 0;
-			inline int Current() { return mCount; }
+			inline int Current() { return m_Count; }
 		protected: 
-			unsigned int mCount;
+			unsigned int m_Count;
 		};
 
 #define wait(sem, ...) sem.Wait(__VA_ARGS__)
@@ -59,7 +59,7 @@ namespace AsuraEngine
 			void Signal() override; 
 			bool Wait(int timeout) override;
 		private:
-			HANDLE mSem;
+			HANDLE m_Sem;
 		};
 
 #endif // ASURA_THREAD_WIN32
diff --git a/source/modules/asura-utils/threading/task.h b/source/modules/asura-utils/threading/task.h
index 9073045..6461fff 100644
--- a/source/modules/asura-utils/threading/task.h
+++ b/source/modules/asura-utils/threading/task.h
@@ -32,7 +32,7 @@ namespace AsuraEngine
 		protected:
 
 			// ȡ�ص�����
-			Luax::LuaxMemberRef mCallback;
+			Luax::LuaxMemberRef m_Callback;
 
 		};
 
diff --git a/source/modules/asura-utils/threading/thread.cpp b/source/modules/asura-utils/threading/thread.cpp
index 0899485..48f287f 100644
--- a/source/modules/asura-utils/threading/thread.cpp
+++ b/source/modules/asura-utils/threading/thread.cpp
@@ -11,217 +11,217 @@ namespace AsuraEngine
 	{
 
 		Thread::Thread(lua_State* luaThread, ThreadType type /*= THREAD_TYPE_DEFERRED*/, uint sleepTime /*= 0*/, const std::string& name /*= ""*/)
-			: mName(name)
-			, mState(THREAD_STATE_IDLE)
-			, mType(type)
-			, mLuaThread(luaThread)
-			, mCallbackThread(nullptr)
-			, mSleepTime(sleepTime)
+			: m_Name(name)
+			, m_State(THREAD_STATE_IDLE)
+			, m_Type(type)
+			, m_LuaThread(luaThread)
+			, m_CallbackThread(nullptr)
+			, m_SleepTime(sleepTime)
 		{
 			LUAX_STATE(luaThread);
 			if (type == THREAD_TYPE_IMMEDIATE)
 			{
 				Luax::LuaxVM* vm = state.GetVM();
 				ASSERT(vm);
-				mCallbackThread = vm->CreateThread();
-				ASSERT(mCallbackThread);
-				SetLuaxMemberRef(state, mCallbackThreadRef, -1);
+			 m_CallbackThread = vm->CreateThread();
+				ASSERT(m_CallbackThread);
+				SetLuaxMemberRef(state, m_CallbackThreadRef, -1);
 				state.Pop(); // callback thread
 			}
 		}
 
 		Thread::~Thread()
 		{
-			if (mImpl)
+			if (m_Impl)
 			{
-				delete mImpl;
-				mImpl = nullptr;
+				delete m_Impl;
+			 m_Impl = nullptr;
 			}
 		}
 
 		bool Thread::AddTask(Task* task)
 		{
-			lock(mTaskQueueMutex)
+			lock(m_TaskQueueMutex)
 			{
 				task->Retain();
-				mTaskQueue.push(task);
+			 m_TaskQueue.push(task);
 			}
 			return true;
 		}
 
 		uint Thread::GetTaskCount()
 		{
-			return mTaskQueue.size();
+			return m_TaskQueue.size();
 		}
 
 		void Thread::Idle()
 		{
-			mState = THREAD_STATE_IDLE;
+		 m_State = THREAD_STATE_IDLE;
 		}
 
 #define try_start_thread(impl)\
-	if (!mImpl) \
+	if (!m_Impl) \
 	{ \
-		mImpl = new impl(); \
-		if (!mImpl->Start(this, stacksize)) \
+	 m_Impl = new impl(); \
+		if (!m_Impl->Start(this, stacksize)) \
 		{ \
-			delete mImpl; \
-			mImpl = nullptr; \
+			delete m_Impl; \
+		 m_Impl = nullptr; \
 		} \
 	}
 
 		bool Thread::Start(bool isDaemon /*= true*/, uint32 stacksize /*= 0*/)
 		{
-			if (mState != THREAD_STATE_IDLE)
+			if (m_State != THREAD_STATE_IDLE)
 				return false;
 
 			// ����Ѿ�����һ��֮ǰ�����ģ��ر�����
-			if (mImpl)
+			if (m_Impl)
 			{
-					delete mImpl;
-					mImpl = nullptr;
+					delete m_Impl;
+				 m_Impl = nullptr;
 			}
 
 #if ASURA_THREAD_WIN32
 			try_start_thread(ThreadImplWin32);
 #endif
 
-			if (!mImpl)
+			if (!m_Impl)
 				return false;
 
-			mIsDaemon = isDaemon;
-			mStateMutex.Lock();
-			mState = THREAD_STATE_RUNNING;
-			mStateMutex.Unlock();
+		 m_IsDaemon = isDaemon;
+		 m_StateMutex.Lock();
+		 m_State = THREAD_STATE_RUNNING;
+		 m_StateMutex.Unlock();
 		}
 
 		void Thread::Pause()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				mState = THREAD_STATE_PAUSED;
+			 m_State = THREAD_STATE_PAUSED;
 			}
 		}
 
 		void Thread::Resume()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				if (mState == THREAD_STATE_PAUSED)
-					mState = THREAD_STATE_RUNNING;
+				if (m_State == THREAD_STATE_PAUSED)
+				 m_State = THREAD_STATE_RUNNING;
 			}
 		}
 
 		void Thread::Stop()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				mState = THREAD_STATE_STOPPED;
+			 m_State = THREAD_STATE_STOPPED;
 			}
 		}
 
 		void Thread::PauseSync()
 		{
 			Pause();
-			wait(mSemPause);
+			wait(m_SemPause);
 		}
 
 		void Thread::ResumeSync()
 		{
 			Resume();
-			wait(mSemResume);
+			wait(m_SemResume);
 		}
 
 		void Thread::StopSync()
 		{
 			Stop();
-			wait(mSemStop);
+			wait(m_SemStop);
 		}
 
 		void Thread::Join()
 		{
-			ASSERT(mImpl); 
-			mImpl->Join();
+			ASSERT(m_Impl); 
+		 m_Impl->Join();
 		}
 
 		ThreadState Thread::GetState()
 		{
 			ThreadState state;
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				state = mState;
+				state = m_State;
 			}
 			return state;
 		}
 
 		bool Thread::IsRunning()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 			return GetState() == THREAD_STATE_RUNNING;
 		}
 
 		bool Thread::IsPaused()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 			return GetState() == THREAD_STATE_PAUSED;
 		}
 
 		bool Thread::IsStopped()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 			return GetState() == THREAD_STATE_STOPPED;
 		}
 
 		bool Thread::IsCurrent()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			return mImpl->IsCurrent(); 
+			return m_Impl->IsCurrent(); 
 		}
 
 		const std::string& Thread::GetName()
 		{
-			return mName;
+			return m_Name;
 		}
 
 		int Thread::Process()
 		{
-			LUAX_STATE(mLuaThread);
+			LUAX_STATE(m_LuaThread);
 
 			do{
 				if (IsRunning())
 				{
-					while (!mTaskQueue.empty())
+					while (!m_TaskQueue.empty())
 					{
-						Task* task = mTaskQueue.front();
+						Task* task = m_TaskQueue.front();
 						if (task && task->Execute())
 						{
-							if (mType == THREAD_TYPE_DEFERRED)
+							if (m_Type == THREAD_TYPE_DEFERRED)
 							{
-								mFinishedMutex.Lock();
+							 m_FinishedMutex.Lock();
 								task->Retain();
-								mFinishedTasks.push(task);
-								mFinishedMutex.Unlock();
+							 m_FinishedTasks.push(task);
+							 m_FinishedMutex.Unlock();
 							}
-							else if (mType == THREAD_TYPE_IMMEDIATE)
+							else if (m_Type == THREAD_TYPE_IMMEDIATE)
 							{
 								// unsafe
-								task->Invoke(mCallbackThread);
+								task->Invoke(m_CallbackThread);
 								this->LuaxRelease<Task>(state, task);
 							}
-							mTaskQueueMutex.Lock();
-							mTaskQueue.pop();
+						 m_TaskQueueMutex.Lock();
+						 m_TaskQueue.pop();
 							task->Release();
-							mTaskQueueMutex.Unlock();
+						 m_TaskQueueMutex.Unlock();
 						}
 					}
 				}
@@ -231,15 +231,15 @@ namespace AsuraEngine
 					break;
 
 				// ����CPUʹ����
-				Sleep(mSleepTime);
+				Sleep(m_SleepTime);
 
-			} while (mIsDaemon);
+			} while (m_IsDaemon);
 
 			// ���ػ��̣߳����е�stop״̬
-			if (!mIsDaemon)
+			if (!m_IsDaemon)
 				Stop();
 
-			signal(mSemStop);
+			signal(m_SemStop);
 
 			// ����״̬ΪIdle
 			Idle();
@@ -252,37 +252,37 @@ namespace AsuraEngine
 		/// 
 		void Thread::Dispatch()
 		{
-			if (mType != THREAD_TYPE_DEFERRED)
+			if (m_Type != THREAD_TYPE_DEFERRED)
 				return;
 
-			LUAX_STATE(mLuaThread);
-			while (!mFinishedTasks.empty())
+			LUAX_STATE(m_LuaThread);
+			while (!m_FinishedTasks.empty())
 			{
-				Task* task = mFinishedTasks.front(); 
+				Task* task = m_FinishedTasks.front(); 
 				if (task)
 				{
-					task->Invoke(mLuaThread);
+					task->Invoke(m_LuaThread);
 					this->LuaxRelease<Task>(state, task);
-					mFinishedMutex.Lock();
-					mFinishedTasks.pop();
+				 m_FinishedMutex.Lock();
+				 m_FinishedTasks.pop();
 					task->Release();
-					mFinishedMutex.Unlock();
+				 m_FinishedMutex.Unlock();
 				}
 			}
 		}
 
 		void Thread::Sleep(uint ms)
 		{
-			ASSERT(mImpl);
-			if (mImpl)
+			ASSERT(m_Impl);
+			if (m_Impl)
 			{
-				mImpl->Sleep(ms);
+			 m_Impl->Sleep(ms);
 			}
 		}
 
 		void Thread::SetSleepTime(uint ms)
 		{
-			mSleepTime = ms;
+		 m_SleepTime = ms;
 		}
 
 	}
diff --git a/source/modules/asura-utils/threading/thread.h b/source/modules/asura-utils/threading/thread.h
index d365fd0..1de4e33 100644
--- a/source/modules/asura-utils/threading/thread.h
+++ b/source/modules/asura-utils/threading/thread.h
@@ -151,46 +151,46 @@ namespace AsuraEngine
 
 			//----------------------------------------------------------------------------//
 
-			ThreadImpl* mImpl;
+			ThreadImpl* m_Impl;
 
-			lua_State*  mLuaThread;
+			lua_State*  m_LuaThread;
 
 			///
 			/// �˴������Ƿ����ػ�ģʽ��
 			///
-			bool mIsDaemon;
+			bool m_IsDaemon;
 
-			std::string mName;
-			ThreadType  mType;
-			uint        mSleepTime;
+			std::string m_Name;
+			ThreadType  m_Type;
+			uint        m_SleepTime;
 
-			ThreadState mState;
-			Mutex       mStateMutex;
+			ThreadState m_State;
+			Mutex       m_StateMutex;
 
 			///
 			/// ͬ��������ص��ź���
 			///
-			Semaphore mSemPause;
-			Semaphore mSemResume;
-			Semaphore mSemStop;
+			Semaphore m_SemPause;
+			Semaphore m_SemResume;
+			Semaphore m_SemStop;
 
 			///
 			/// ���������������
 			///
-			std::queue<Task*> mTaskQueue;
-			Mutex             mTaskQueueMutex;
+			std::queue<Task*> m_TaskQueue;
+			Mutex             m_TaskQueueMutex;
 
 			/// 
 			/// �ӳ�ģʽʹ��
 			///
-			std::queue<Task*> mFinishedTasks;
-			Mutex             mFinishedMutex;
+			std::queue<Task*> m_FinishedTasks;
+			Mutex             m_FinishedMutex;
 
 			///
 			/// ����ģʽʹ�ã��ص�ʹ�õ�lua�߳�
 			///
-			lua_State*          mCallbackThread;
-			Luax::LuaxMemberRef mCallbackThreadRef;
+			lua_State*          m_CallbackThread;
+			Luax::LuaxMemberRef m_CallbackThreadRef;
 
 		};
 
diff --git a/source/modules/asura-utils/threading/thread_impl_win32.cpp b/source/modules/asura-utils/threading/thread_impl_win32.cpp
index 0e1569c..61b1c13 100644
--- a/source/modules/asura-utils/threading/thread_impl_win32.cpp
+++ b/source/modules/asura-utils/threading/thread_impl_win32.cpp
@@ -22,15 +22,15 @@ namespace AsuraEngine
 
 		ThreadImplWin32::~ThreadImplWin32()
 		{
-			if (!mHandle) return;
-			::CloseHandle(mHandle);
-			mHandle = 0;
+			if (!m_Handle) return;
+			::CloseHandle(m_Handle);
+		 m_Handle = 0;
 		}
 
 		bool ThreadImplWin32::Start(Threadable* thread, uint32 stacksize/*=0*/)
 		{
 			assert(!IsRunning());
-			mHandle = ::CreateThread(
+		 m_Handle = ::CreateThread(
 				NULL
 				, stacksize
 				, _thread_win32_runner
@@ -38,18 +38,18 @@ namespace AsuraEngine
 				, 0 /*���������������*/
 			  , NULL);
 
-			return mHandle;
+			return m_Handle;
 		}
 
 		void ThreadImplWin32::Join()
 		{
 			// ���̵߳ȴ����̷߳���
-			::WaitForSingleObject(mHandle, INFINITE);
+			::WaitForSingleObject(m_Handle, INFINITE);
 		}
 
 		void ThreadImplWin32::Kill()
 		{
-			::TerminateThread(mHandle, FALSE);
+			::TerminateThread(m_Handle, FALSE);
 		}
 
 		void ThreadImplWin32::Sleep(uint ms)
@@ -59,10 +59,10 @@ namespace AsuraEngine
 
 		bool ThreadImplWin32::IsRunning()
 		{
-			if (mHandle) {
+			if (m_Handle) {
 				DWORD exitCode = 0;
 				// https://blog.csdn.net/yuanmeng567/article/details/19485719
-				::GetExitCodeThread(mHandle, &exitCode);
+				::GetExitCodeThread(m_Handle, &exitCode);
 				return exitCode == STILL_ACTIVE;
 			}
 			return false;
@@ -70,7 +70,7 @@ namespace AsuraEngine
 
 		bool ThreadImplWin32::IsCurrent()
 		{
-			return mHandle == ::GetCurrentThread();
+			return m_Handle == ::GetCurrentThread();
 		}
 
 	}
diff --git a/source/modules/asura-utils/threading/thread_impl_win32.h b/source/modules/asura-utils/threading/thread_impl_win32.h
index fdcfc2b..d1b7ae5 100644
--- a/source/modules/asura-utils/threading/thread_impl_win32.h
+++ b/source/modules/asura-utils/threading/thread_impl_win32.h
@@ -35,7 +35,7 @@ namespace AsuraEngine
 
 		private:
 
-			HANDLE mHandle;
+			HANDLE m_Handle;
 
 		};