*修改成员变量前缀

14 files changed, 178 insertions, 178 deletions

diff --git a/source/modules/asura-utils/io/binding/_file_data.cpp b/source/modules/asura-utils/io/binding/_file_data.cpp
index 09a0643..f4f6584 100644
--- a/source/modules/asura-utils/io/binding/_file_data.cpp
+++ b/source/modules/asura-utils/io/binding/_file_data.cpp
@@ -52,7 +52,7 @@ namespace AsuraEngine
 		LUAX_IMPL_METHOD(FileData, _GetDataBuffer)
 		{
 			LUAX_PREPARE(L, FileData);
-			self->PushLuaxMemberRef(state, self->mDataRef);
+			self->PushLuaxMemberRef(state, self->m_DataRef);
 			return 1;
 		}
 
diff --git a/source/modules/asura-utils/io/binding/_file_system.cpp b/source/modules/asura-utils/io/binding/_file_system.cpp
index 3843451..0dc24d0 100644
--- a/source/modules/asura-utils/io/binding/_file_system.cpp
+++ b/source/modules/asura-utils/io/binding/_file_system.cpp
@@ -206,8 +206,8 @@ namespace AsuraEngine
 			FileData* fd = fs->Read(path);
 			if (fd)
 			{
-				fd->mData->PushLuaxUserdata(state); 
-				fd->SetLuaxMemberRef(state, fd->mDataRef, -1); // fd->mDataRef = data buffer
+				fd->m_Data->PushLuaxUserdata(state); 
+				fd->SetLuaxMemberRef(state, fd->m_DataRef, -1); // fd->m_DataRef = data buffer
 				state.Pop(1); // data buffer
 				fd->PushLuaxUserdata(state);
 			}
diff --git a/source/modules/asura-utils/io/binding/_io_task.cpp b/source/modules/asura-utils/io/binding/_io_task.cpp
index b3c5988..4da8dc3 100644
--- a/source/modules/asura-utils/io/binding/_io_task.cpp
+++ b/source/modules/asura-utils/io/binding/_io_task.cpp
@@ -35,9 +35,9 @@ namespace AsuraEngine
 			bool cbk = state.GetTop() >= 4 && state.IsType(4, LUA_TFUNCTION);
 
 			IOTask* task = new IOTask(path, db, type);
-			task->SetLuaxMemberRef(state, task->mBufferRef, 2);
+			task->SetLuaxMemberRef(state, task->m_BufferRef, 2);
 			if(cbk)
-				task->SetLuaxMemberRef(state, task->mCallback, 4);
+				task->SetLuaxMemberRef(state, task->m_Callback, 4);
 			task->PushLuaxUserdata(state);
 			return 1;
 		}
diff --git a/source/modules/asura-utils/io/data_buffer.cpp b/source/modules/asura-utils/io/data_buffer.cpp
index 36e13c7..37f749c 100644
--- a/source/modules/asura-utils/io/data_buffer.cpp
+++ b/source/modules/asura-utils/io/data_buffer.cpp
@@ -10,15 +10,15 @@ namespace AsuraEngine
 	{
 
 		DataBuffer::DataBuffer(DataBuffer& src)
-			: mSize(0)
-			, mCapacity(0)
-			, mBytes(nullptr)
+			: m_Size(0)
+			, m_Capacity(0)
+			, m_Bytes(nullptr)
 		{
 			// ��ʼ������
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				mCapacity = src.mSize;
-				mBytes = new byte[mCapacity];
+			 m_Capacity = src.m_Size;
+			 m_Bytes = new byte[m_Capacity];
 				Clear();
 
 				Load(src);
@@ -26,27 +26,27 @@ namespace AsuraEngine
 		}
 
 		DataBuffer::DataBuffer(std::size_t capacity)
-			: mSize(0)
-			, mCapacity(0)
-			, mBytes(nullptr)
+			: m_Size(0)
+			, m_Capacity(0)
+			, m_Bytes(nullptr)
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				mCapacity = capacity;
-				mBytes = new byte[mCapacity];
+			 m_Capacity = capacity;
+			 m_Bytes = new byte[m_Capacity];
 				Clear();
 			}
 		}
 
 		DataBuffer::DataBuffer(const void* data, std::size_t size)
-			: mCapacity(0)
-			, mSize(0)
-			, mBytes(nullptr)
+			: m_Capacity(0)
+			, m_Size(0)
+			, m_Bytes(nullptr)
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				mCapacity = size;
-				mBytes = new byte[mCapacity];
+			 m_Capacity = size;
+			 m_Bytes = new byte[m_Capacity];
 				Clear();
 
 				Load(data, size);
@@ -55,23 +55,23 @@ namespace AsuraEngine
 
 		DataBuffer::~DataBuffer()
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				delete[] mBytes;
+				delete[] m_Bytes;
 			}
 		}
 
 		void DataBuffer::Refactor(size_t capacity)
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				if (!mBytes || mCapacity != capacity)
+				if (!m_Bytes || m_Capacity != capacity)
 				{
-					if(mBytes)
-						delete[] mBytes;
-					mCapacity = capacity;
-					mBytes = new byte[mCapacity];
-					mSize = 0;
+					if(m_Bytes)
+						delete[] m_Bytes;
+				 m_Capacity = capacity;
+				 m_Bytes = new byte[m_Capacity];
+				 m_Size = 0;
 				}
 				Clear();
 			}
@@ -79,7 +79,7 @@ namespace AsuraEngine
 
 		void DataBuffer::Load(DataBuffer& db)
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
 				Load(db.GetData(), db.GetSize());
 			}
@@ -87,69 +87,69 @@ namespace AsuraEngine
 
 		void DataBuffer::Load(const void* data, std::size_t size)
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				ASSERT(mCapacity >= size);
-				memcpy(mBytes, data, size);
-				mSize = size;
+				ASSERT(m_Capacity >= size);
+				memcpy(m_Bytes, data, size);
+			 m_Size = size;
 			}
 		}
 
 		void DataBuffer::Move(void* bytes, std::size_t size)
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				if (mBytes == bytes)
+				if (m_Bytes == bytes)
 				{
 					// �������������������sizeֵ���ڶ��ļ�ʱ������
-					mSize = size;
+				 m_Size = size;
 				}
 				else
 				{
-					if (mBytes)
-						delete[] mBytes;
-					mBytes = (byte*)bytes;
-					mSize = size;
-					mCapacity = size;
+					if (m_Bytes)
+						delete[] m_Bytes;
+				 m_Bytes = (byte*)bytes;
+				 m_Size = size;
+				 m_Capacity = size;
 				}
 			}
 		}
 
 		byte* DataBuffer::GetData()
 		{
-			return mBytes;
+			return m_Bytes;
 		}
 
 		void DataBuffer::Clear()
 		{
-			lock(mMutex)
+			lock(m_Mutex)
 			{
-				if (mBytes)
+				if (m_Bytes)
 				{
-					memset(mBytes, 0, mSize);
-					mSize = 0;
+					memset(m_Bytes, 0, m_Size);
+				 m_Size = 0;
 				}
 			}
 		}
 		
 		std::size_t DataBuffer::GetSize()
 		{
-			return mSize;
+			return m_Size;
 		}
 
 		std::size_t DataBuffer::GetCapacity()
 		{
-			return mCapacity;
+			return m_Capacity;
 		}
 
 		void DataBuffer::Lock()
 		{
-			mMutex.Lock();
+		 m_Mutex.Lock();
 		}
 
 		void DataBuffer::Unlock()
 		{
-			mMutex.Unlock();
+		 m_Mutex.Unlock();
 		}
 
 	}
diff --git a/source/modules/asura-utils/io/data_buffer.h b/source/modules/asura-utils/io/data_buffer.h
index c60444e..53ed603 100644
--- a/source/modules/asura-utils/io/data_buffer.h
+++ b/source/modules/asura-utils/io/data_buffer.h
@@ -67,15 +67,15 @@ namespace AsuraEngine
 			///
 			/// Buffer�׵�ַ���������ݵij���
 			///
-			byte* mBytes;
-			size_t mSize;
+			byte* m_Bytes;
+			size_t m_Size;
 
 			///
 			/// Buffer������
 			///
-			size_t mCapacity;
+			size_t m_Capacity;
 
-			AEThreading::Mutex mMutex;
+			AEThreading::Mutex m_Mutex;
 
 		};
 
diff --git a/source/modules/asura-utils/io/file.cpp b/source/modules/asura-utils/io/file.cpp
index 9e89c85..2061fb1 100644
--- a/source/modules/asura-utils/io/file.cpp
+++ b/source/modules/asura-utils/io/file.cpp
@@ -10,25 +10,25 @@ namespace AsuraEngine
 	{
 
 		File::File(const std::string& filename)
-			: mFileName(filename)
-			, mFileHandle(nullptr)
-			, mMode(FILE_MODE_CLOSED)
-			, mBufferMode(BUFFER_MODE_NONE)
-			, mBufferSize(0)
+			: m_FileName(filename)
+			, m_FileHandle(nullptr)
+			, m_Mode(FILE_MODE_CLOSED)
+			, m_BufferMode(BUFFER_MODE_NONE)
+			, m_BufferSize(0)
 		{
 			size_t dot = filename.rfind('.');
 			if (dot != std::string::npos)
 			{
-				mExtension = filename.substr(dot + 1);
-				mName = filename.substr(0, dot);
+			 m_Extension = filename.substr(dot + 1);
+			 m_Name = filename.substr(0, dot);
 			}
 			else
-				mName = filename;
+			 m_Name = filename;
 		}
 
 		File::~File()
 		{
-			if (mMode != FILE_MODE_CLOSED)
+			if (m_Mode != FILE_MODE_CLOSED)
 				Close();
 		}
 
@@ -40,8 +40,8 @@ namespace AsuraEngine
 			if (mode == FILE_MODE_CLOSED)
 				return false;
 
-			if (mode == FILE_MODE_READ && !PHYSFS_exists(mFileName.c_str()))
-				throw Exception("Could NOT open file %s. Does not exist.", mFileName.c_str());
+			if (mode == FILE_MODE_READ && !PHYSFS_exists(m_FileName.c_str()))
+				throw Exception("Could NOT open file %s. Does not exist.", m_FileName.c_str());
 
 			if (mode == FILE_MODE_APPEND || mode == FILE_MODE_WRITE)
 			{
@@ -52,7 +52,7 @@ namespace AsuraEngine
 			}
 
 			// �Ѿ���֮ǰ�򿪹����Ͳ��ٴ����µ�handle��
-			if (mFileHandle != nullptr)
+			if (m_FileHandle != nullptr)
 				return true;
 
 			PHYSFS_getLastErrorCode();
@@ -62,13 +62,13 @@ namespace AsuraEngine
 			switch (mode)
 			{
 			case FILE_MODE_READ:
-				handle = PHYSFS_openRead(mFileName.c_str());
+				handle = PHYSFS_openRead(m_FileName.c_str());
 				break;
 			case FILE_MODE_APPEND:
-				handle = PHYSFS_openAppend(mFileName.c_str());
+				handle = PHYSFS_openAppend(m_FileName.c_str());
 				break;
 			case FILE_MODE_WRITE:
-				handle = PHYSFS_openWrite(mFileName.c_str());
+				handle = PHYSFS_openWrite(m_FileName.c_str());
 				break;
 			}
 
@@ -77,45 +77,45 @@ namespace AsuraEngine
 				const char *err = PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode());
 				if (err == nullptr)
 					err = "unknown error";
-				throw Exception("Could not open file %s (%s)", mFileName.c_str(), err);
+				throw Exception("Could not open file %s (%s)", m_FileName.c_str(), err);
 			}
 
-			mFileHandle = handle;
-			mMode = mode; 
+		 m_FileHandle = handle;
+		 m_Mode = mode; 
 
-			if (mFileHandle && !SetBuffer(mBufferMode,mBufferSize))
+			if (m_FileHandle && !SetBuffer(m_BufferMode,m_BufferSize))
 			{
-				mBufferMode = BUFFER_MODE_NONE; 
-				mBufferSize = 0;
+			 m_BufferMode = BUFFER_MODE_NONE; 
+			 m_BufferSize = 0;
 			}
 
-			return mFileHandle != nullptr;
+			return m_FileHandle != nullptr;
 		}
 
 		bool File::Close()
 		{
-			if (mFileHandle == nullptr || !PHYSFS_close(mFileHandle))
+			if (m_FileHandle == nullptr || !PHYSFS_close(m_FileHandle))
 				return false;
-			mMode = FILE_MODE_CLOSED;
-			mFileHandle = nullptr;
+		 m_Mode = FILE_MODE_CLOSED;
+		 m_FileHandle = nullptr;
 			return true;
 		}
 
 		bool File::IsOpen()
 		{
-			return mMode != FILE_MODE_CLOSED && mFileHandle != nullptr;
+			return m_Mode != FILE_MODE_CLOSED && m_FileHandle != nullptr;
 		}
 
 		size_t File::GetSize()
 		{
-			if (mFileHandle == nullptr)
+			if (m_FileHandle == nullptr)
 			{
 				Open(FILE_MODE_READ);
-				size_t size = PHYSFS_fileLength(mFileHandle);
+				size_t size = PHYSFS_fileLength(m_FileHandle);
 				Close(); 
 				return size;
 			}
-			return PHYSFS_fileLength(mFileHandle);
+			return PHYSFS_fileLength(m_FileHandle);
 		}
 
 		size_t File::Read(ASURA_OUT DataBuffer* dst, size_t length)
@@ -125,17 +125,17 @@ namespace AsuraEngine
 			if (dst->GetCapacity() < length)
 				throw Exception("Data buffer is too small compares to read length.");
 
-			if (!mFileHandle || mMode != FILE_MODE_READ)
-				throw Exception("File \"%s\" is not opened for reading", mFileName);
+			if (!m_FileHandle || m_Mode != FILE_MODE_READ)
+				throw Exception("File \"%s\" is not opened for reading", m_FileName);
 
-			size_t max = PHYSFS_fileLength(mFileHandle);
+			size_t max = PHYSFS_fileLength(m_FileHandle);
 			length = (length > max) ? max : length;
 
 			if (length < 0)
 				throw Exception("Invalid read size.");
 
 			dst->Lock();
-			size_t size = PHYSFS_readBytes(mFileHandle, dst->GetData(), length);
+			size_t size = PHYSFS_readBytes(m_FileHandle, dst->GetData(), length);
 			dst->Unlock();
 			return size;
 		}
@@ -144,17 +144,17 @@ namespace AsuraEngine
 		{
 			ASSERT(dst);
 
-			if (!mFileHandle || mMode != FILE_MODE_READ)
-				throw Exception("File \"%s\" is not opened for reading", mFileName);
+			if (!m_FileHandle || m_Mode != FILE_MODE_READ)
+				throw Exception("File \"%s\" is not opened for reading", m_FileName);
 
-			size_t length = PHYSFS_fileLength(mFileHandle);
+			size_t length = PHYSFS_fileLength(m_FileHandle);
 
 			if (dst->GetCapacity() < length)
 				throw Exception("Data buffer is too small compares to file length.");
 
 			dst->Lock();
 			byte* data = dst->GetData();
-			size_t size = PHYSFS_readBytes(mFileHandle, data, length);
+			size_t size = PHYSFS_readBytes(m_FileHandle, data, length);
 			dst->Move(data, length);
 			dst->Unlock();
 			return size;
@@ -176,25 +176,25 @@ namespace AsuraEngine
 
 		bool File::IsEOF()
 		{
-			return mFileHandle == nullptr || test_eof(this, mFileHandle);
+			return m_FileHandle == nullptr || test_eof(this, m_FileHandle);
 		}
 
 		size_t File::Tell()
 		{
-			if (!mFileHandle)
+			if (!m_FileHandle)
 				return - 1;
 
-			return PHYSFS_tell(mFileHandle);
+			return PHYSFS_tell(m_FileHandle);
 		}
 
 		bool File::Seek(size_t pos)
 		{
-			return mFileHandle != nullptr && PHYSFS_seek(mFileHandle, pos) != 0;
+			return m_FileHandle != nullptr && PHYSFS_seek(m_FileHandle, pos) != 0;
 		}
 
 		bool File::Write(ASURA_REF DataBuffer* src)
 		{
-			if (!mFileHandle || (mMode != FILE_MODE_APPEND && mMode != FILE_MODE_WRITE))
+			if (!m_FileHandle || (m_Mode != FILE_MODE_APPEND && m_Mode != FILE_MODE_WRITE))
 				throw Exception("File is not opened for writing.");
 
 			byte* data = src->GetData();
@@ -203,13 +203,13 @@ namespace AsuraEngine
 			if (size < 0)
 				throw Exception("Invalid write size.");
 
-			size_t written = PHYSFS_writeBytes(mFileHandle, data, size);
+			size_t written = PHYSFS_writeBytes(m_FileHandle, data, size);
 
 			if (written != src->GetSize())
 				return false; 
 
 			// �������
-			if (mBufferSize == BUFFER_MODE_LINE && mBufferSize > size)
+			if (m_BufferSize == BUFFER_MODE_LINE && m_BufferSize > size)
 			{
 				if (memchr(data, '\n', size) != nullptr)
 					Flush();
@@ -220,10 +220,10 @@ namespace AsuraEngine
 
 		bool File::Flush()
 		{
-			if (!mFileHandle || (mMode != FILE_MODE_WRITE && mMode != FILE_MODE_APPEND))
+			if (!m_FileHandle || (m_Mode != FILE_MODE_WRITE && m_Mode != FILE_MODE_APPEND))
 				throw Exception("File is not opened for writing.");
 
-			return PHYSFS_flush(mFileHandle) != 0;
+			return PHYSFS_flush(m_FileHandle) != 0;
 		}
 
 		bool File::SetBuffer(BufferMode mode, size_t size)
@@ -235,8 +235,8 @@ namespace AsuraEngine
 			// File::open.
 			if (!IsOpen())
 			{
-				mBufferMode = mode;
-				mBufferSize = size;
+			 m_BufferMode = mode;
+			 m_BufferSize = size;
 				return true;
 			}
 
@@ -246,48 +246,48 @@ namespace AsuraEngine
 			{
 			case BUFFER_MODE_NONE:
 			default:
-				ret = PHYSFS_setBuffer(mFileHandle, 0);
+				ret = PHYSFS_setBuffer(m_FileHandle, 0);
 				size = 0;
 				break;
 			case BUFFER_MODE_LINE:
 			case BUFFER_MODE_FULL:
-				ret = PHYSFS_setBuffer(mFileHandle, size);
+				ret = PHYSFS_setBuffer(m_FileHandle, size);
 				break;
 			}
 
 			if (ret == 0)
 				return false;
 
-			mBufferMode = mode;
-			mBufferSize = size;
+		 m_BufferMode = mode;
+		 m_BufferSize = size;
 
 			return true;
 		}
 
 		File::BufferMode File::GetBuffer(ASURA_OUT size_t& size) 
 		{
-			size = mBufferSize; 
-			return mBufferMode; 
+			size = m_BufferSize; 
+			return m_BufferMode; 
 		}
 
 		const std::string& File::GetFileName()
 		{
-			return mFileName;
+			return m_FileName;
 		}
 
 		const std::string& File::GetName()
 		{
-			return mName;
+			return m_Name;
 		}
 
 		const std::string& File::GetExtension()
 		{
-			return mExtension;
+			return m_Extension;
 		}
 
 		File::FileMode File::GetMode()
 		{
-			return mMode;
+			return m_Mode;
 		}
 
 	}
diff --git a/source/modules/asura-utils/io/file.h b/source/modules/asura-utils/io/file.h
index 56077e0..16de42b 100644
--- a/source/modules/asura-utils/io/file.h
+++ b/source/modules/asura-utils/io/file.h
@@ -107,13 +107,13 @@ namespace AsuraEngine
 
 		private:
 
-			PHYSFS_File* mFileHandle; ///< physfs �ļ�
-			std::string  mFileName;   ///< �ļ���
-			std::string  mExtension;  ///< �����������չ��
-			std::string  mName;       ///< �����������չ�����ļ���
-			FileMode     mMode;       ///< �ļ���ģʽ
-			BufferMode   mBufferMode;	///< д�뻺����ģʽ
-			size_t       mBufferSize;	///< д�뻺������С
+			PHYSFS_File* m_FileHandle; ///< physfs �ļ�
+			std::string  m_FileName;   ///< �ļ���
+			std::string  m_Extension;  ///< �����������չ��
+			std::string  m_Name;       ///< �����������չ�����ļ���
+			FileMode     m_Mode;       ///< �ļ���ģʽ
+			BufferMode   m_BufferMode;	///< д�뻺����ģʽ
+			size_t       m_BufferSize;	///< д�뻺������С
 
 			LUAX_DECL_ENUM(FileMode);
 			LUAX_DECL_ENUM(BufferMode);
diff --git a/source/modules/asura-utils/io/file_data.cpp b/source/modules/asura-utils/io/file_data.cpp
index ad58db9..30fa5bf 100644
--- a/source/modules/asura-utils/io/file_data.cpp
+++ b/source/modules/asura-utils/io/file_data.cpp
@@ -6,53 +6,53 @@ namespace AsuraEngine
 	{
 
 		FileData::FileData(const std::string& filename)
-			: mData(nullptr)
-			, mFileName(filename)
+			: m_Data(nullptr)
+			, m_FileName(filename)
 		{
 			size_t dot = filename.rfind('.');
 			if (dot != std::string::npos)
 			{
-				mExtension = filename.substr(dot + 1);
-				mName = filename.substr(0, dot);
+			 m_Extension = filename.substr(dot + 1);
+			 m_Name = filename.substr(0, dot);
 			}
 			else
-				mName = filename;
+			 m_Name = filename;
 		}
 
 		FileData::~FileData()
 		{
-			if (mData)
-				mData->Release();
+			if (m_Data)
+			 m_Data->Release();
 		}
 
 		const std::string& FileData::GetFileName()
 		{
-			return mFileName;
+			return m_FileName;
 		}
 
 		const std::string& FileData::GetExtension()
 		{
-			return mExtension;
+			return m_Extension;
 		}
 
 		const std::string& FileData::GetName()
 		{
-			return mName;
+			return m_Name;
 		}
 
 		void FileData::BindData(ASURA_MOVE DataBuffer* buffer)
 		{
 			if (!buffer)
 				return;
-			if (mData)
-				mData->Release();
-			mData = buffer;
-			mData->Retain();
+			if (m_Data)
+			 m_Data->Release();
+		 m_Data = buffer;
+		 m_Data->Retain();
 		}
 
 		DataBuffer* FileData::GetDataBuffer()
 		{
-			return mData;
+			return m_Data;
 		}
 
 	}
diff --git a/source/modules/asura-utils/io/file_data.h b/source/modules/asura-utils/io/file_data.h
index cd69477..ecc072b 100644
--- a/source/modules/asura-utils/io/file_data.h
+++ b/source/modules/asura-utils/io/file_data.h
@@ -49,12 +49,12 @@ namespace AsuraEngine
 			///
 			/// Data buffer������filedata����ʱ���٣���lua���ü���Ϊ0ʱ��lua����GC���١�����mDataʱ������һ����Ա���á�
 			///
-			ASURA_REF DataBuffer* mData;
-			Luax::LuaxMemberRef   mDataRef;
+			ASURA_REF DataBuffer* m_Data;
+			Luax::LuaxMemberRef   m_DataRef;
 
-			std::string mFileName;  ///< ������չ�����ļ���
-			std::string mExtension; ///< �����������չ��
-			std::string mName;      ///< ��������ͺ�׺���ļ���
+			std::string m_FileName;  ///< ������չ�����ļ���
+			std::string m_Extension; ///< �����������չ��
+			std::string m_Name;      ///< ��������ͺ�׺���ļ���
 
 			LUAX_DECL_METHOD(_GetDataBuffer);
 			LUAX_DECL_METHOD(_GetFileName);
diff --git a/source/modules/asura-utils/io/file_system.cpp b/source/modules/asura-utils/io/file_system.cpp
index 20f3cb2..f68bad6 100644
--- a/source/modules/asura-utils/io/file_system.cpp
+++ b/source/modules/asura-utils/io/file_system.cpp
@@ -23,7 +23,7 @@ namespace AsuraEngine
 
 		Filesystem::~Filesystem()
 		{
-			if (mInited) //PHYSFS_isInit
+			if (m_Inited) //PHYSFS_isInit
 				PHYSFS_deinit();
 		}
 
@@ -32,12 +32,12 @@ namespace AsuraEngine
 			if (!PHYSFS_init(arg0))
 				throw Exception("Failed to initialize filesystem: %s", PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
 
-			mInited = true;
+		 m_Inited = true;
 		}
 
 		bool Filesystem::Mount(const std::string& locpath, const std::string& montpoint/* = "/"*/, bool prepend /*= false*/)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return false;
 
 			return PHYSFS_mount(locpath.c_str(), montpoint.c_str(), !prepend);
@@ -45,11 +45,11 @@ namespace AsuraEngine
 
 		bool Filesystem::Mount(DataBuffer* db, const std::string& archivename, const std::string& mountpoint /*= "/"*/, bool prepend /*= false*/)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return false;
 			if (PHYSFS_mountMemory(db->GetData(), db->GetSize(), nullptr, archivename.c_str(), mountpoint.c_str(), !prepend))
 			{
-				mMountData[archivename] = db;
+			 m_MountData[archivename] = db;
 				return true;
 			}
 			return false;
@@ -57,14 +57,14 @@ namespace AsuraEngine
 
 		bool Filesystem::Unmount(const std::string& locpath)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return false;
 
 			// ����ǹ鵵����ӳ����ɾ����
-			auto datait = mMountData.find(locpath);
-			if (datait != mMountData.end() && PHYSFS_unmount(locpath.c_str()) != 0)
+			auto datait = m_MountData.find(locpath);
+			if (datait != m_MountData.end() && PHYSFS_unmount(locpath.c_str()) != 0)
 			{
-				mMountData.erase(datait);
+			 m_MountData.erase(datait);
 				return true;
 			}
 
@@ -73,7 +73,7 @@ namespace AsuraEngine
 
 		bool Filesystem::Unmount(DataBuffer* db)
 		{
-			for (const auto& dp : mMountData)
+			for (const auto& dp : m_MountData)
 			{
 				if (dp.second == db)
 				{
@@ -85,7 +85,7 @@ namespace AsuraEngine
 
 		bool Filesystem::GetMountPoint(const std::string& locpath, ASURA_OUT std::string& mountpoint)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return false;
 			const char* point = PHYSFS_getMountPoint(locpath.c_str());
 			if (point != nullptr)
@@ -98,7 +98,7 @@ namespace AsuraEngine
 
 		void Filesystem::SetWriteDirectory(const std::string locpath)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return;
 			if (!PHYSFS_setWriteDir(locpath.c_str()))
 				throw Exception("Failed to set write directory %s", locpath.c_str());
@@ -116,7 +116,7 @@ namespace AsuraEngine
 
 		bool Filesystem::NewDirectory(const std::string& path)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return false;
 			if (!PHYSFS_getWriteDir())
 				return false;
@@ -159,7 +159,7 @@ namespace AsuraEngine
 
 		bool Filesystem::Remove(const std::string& path)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return false;
 			if (PHYSFS_getWriteDir() == 0)
 				return false;
@@ -172,7 +172,7 @@ namespace AsuraEngine
 
 		bool Filesystem::GetFileInfo(const std::string& filepath, ASURA_OUT FileInfo* info)
 		{
-			if (!mInited)
+			if (!m_Inited)
 				return false;
 
 			PHYSFS_Stat stat = {};
diff --git a/source/modules/asura-utils/io/file_system.h b/source/modules/asura-utils/io/file_system.h
index 849cbb6..9b4c4be 100644
--- a/source/modules/asura-utils/io/file_system.h
+++ b/source/modules/asura-utils/io/file_system.h
@@ -78,9 +78,9 @@ namespace AsuraEngine
 
 			typedef std::map<std::string, DataBuffer*> MountDataMap;
 
-			bool         mInited;    ///< �Ƿ��ʼ���ɹ�
-			std::string  mCwd;       ///< ��ǰִ���ļ��Ĺ���Ŀ¼
-			MountDataMap mMountData; ///< ��·����ѹ���ĵ���ӳ��
+			bool         m_Inited;    ///< �Ƿ��ʼ���ɹ�
+			std::string  m_Cwd;       ///< ��ǰִ���ļ��Ĺ���Ŀ¼
+			MountDataMap m_MountData; ///< ��·����ѹ���ĵ���ӳ��
 
 			LUAX_DECL_METHOD(_Init);
 			LUAX_DECL_METHOD(_Mount);
diff --git a/source/modules/asura-utils/io/io_batch_task.h b/source/modules/asura-utils/io/io_batch_task.h
index c0be921..0a551e8 100644
--- a/source/modules/asura-utils/io/io_batch_task.h
+++ b/source/modules/asura-utils/io/io_batch_task.h
@@ -21,7 +21,7 @@ namespace AsuraEngine
 			/// �������ÿһ���Ľṹ���£�
 			/// { path = "", }
 			/// 
-			Luax::LuaxMemberRef mTasks;
+			Luax::LuaxMemberRef m_Tasks;
 
 		};
 
diff --git a/source/modules/asura-utils/io/io_task.cpp b/source/modules/asura-utils/io/io_task.cpp
index ca03b09..6c323de 100644
--- a/source/modules/asura-utils/io/io_task.cpp
+++ b/source/modules/asura-utils/io/io_task.cpp
@@ -12,8 +12,8 @@ namespace AsuraEngine
 	{
 
 		IOTask::IOTask(const std::string& path, DataBuffer* buffer, IOTaskType type)
-			: mPath(path)
-			, mBuffer(buffer)
+			: m_Path(path)
+			, m_Buffer(buffer)
 		{
 			if (buffer)
 				buffer->Retain();
@@ -21,24 +21,24 @@ namespace AsuraEngine
 
 		IOTask::~IOTask()
 		{
-			if (mBuffer)
-				mBuffer->Release();
+			if (m_Buffer)
+			 m_Buffer->Release();
 		}
 
 		bool IOTask::Execute()
 		{
-			File file(mPath);
-			if (mType == IOTASK_TYPE_WRITE)
+			File file(m_Path);
+			if (m_Type == IOTASK_TYPE_WRITE)
 			{
 
 			}
 			// ��path��ȡ���ݱ�����mBuffer��
-			else if (mType == IOTASK_TYPE_READ)
+			else if (m_Type == IOTASK_TYPE_READ)
 			{
-				if (!mBuffer)
+				if (!m_Buffer)
 					return false; 
 				file.Open(File::FILE_MODE_READ);
-				file.ReadAll(mBuffer);
+				file.ReadAll(m_Buffer);
 				file.Close();
 			}
 			return true;
@@ -46,12 +46,12 @@ namespace AsuraEngine
 
 		void IOTask::Invoke(lua_State* invokeThreaad)
 		{
-			if (mCallback)
+			if (m_Callback)
 			{
 				LuaxScopedState state(invokeThreaad);
-				if (this->PushLuaxMemberRef(state, mCallback))
+				if (this->PushLuaxMemberRef(state, m_Callback))
 				{
-					this->PushLuaxMemberRef(state, mBufferRef);
+					this->PushLuaxMemberRef(state, m_BufferRef);
 					state.Call(1, 0);
 				}
 			}
diff --git a/source/modules/asura-utils/io/io_task.h b/source/modules/asura-utils/io/io_task.h
index 0cf5023..8026a24 100644
--- a/source/modules/asura-utils/io/io_task.h
+++ b/source/modules/asura-utils/io/io_task.h
@@ -42,11 +42,11 @@ namespace AsuraEngine
 
 			LUAX_DECL_METHOD(_New);
 
-			std::string mPath;
-			IOTaskType  mType;
+			std::string m_Path;
+			IOTaskType  m_Type;
 
-			DataBuffer*         mBuffer;
-			Luax::LuaxMemberRef mBufferRef;
+			DataBuffer*         m_Buffer;
+			Luax::LuaxMemberRef m_BufferRef;
 
 		};