*修改成员变量前缀

27 files changed, 221 insertions, 221 deletions

diff --git a/bin/win64/01-window.exe b/bin/win64/01-window.exe
index d504084..6727afd 100644
--- a/bin/win64/01-window.exe
+++ b/bin/win64/01-window.exe
diff --git a/source/modules/asura-core/application.h b/source/modules/asura-core/application.h
index ccb39d7..0cde32f 100644
--- a/source/modules/asura-core/application.h
+++ b/source/modules/asura-core/application.h
@@ -69,12 +69,12 @@ namespace AsuraEngine
 		/// ����lua����̫ʹ���ˡ�������C++����д��Ȼ��ע��һ���ص�������������һ���̴߳���lua_State��ע�ắ����ִ�к󷢻�����
 		/// �����̵߳�lua_State����ֻ֤��һ��nativeʵ��֮��һ��lua_State�󶨡�
 		///
-		Luax::LuaxVM* mVM;
+		Luax::LuaxVM* m_VM;
 
 		///
 		/// �����Asura libs���ᰴ�ն���˳���ʼ���������˳�ʱִ���˳�������
 		///
-		std::queue<Module*> mModules;
+		std::queue<Module*> m_Modules;
 
 	};
 
diff --git a/source/modules/asura-core/font/string.cpp b/source/modules/asura-core/font/string.cpp
index 72acaa6..1731338 100644
--- a/source/modules/asura-core/font/string.cpp
+++ b/source/modules/asura-core/font/string.cpp
@@ -20,21 +20,21 @@
 //		////////////////////////////////////////////////////////////
 //		String::String(char ansiChar, const std::locale& locale)
 //		{
-//			mString += Utf32::DecodeAnsi(ansiChar, locale);
+//		 m_String += Utf32::DecodeAnsi(ansiChar, locale);
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::String(wchar_t wideChar)
 //		{
-//			mString += Utf32::DecodeWide(wideChar);
+//		 m_String += Utf32::DecodeWide(wideChar);
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::String(uint32 utf32Char)
 //		{
-//			mString += utf32Char;
+//		 m_String += utf32Char;
 //		}
 //
 //
@@ -46,8 +46,8 @@
 //				std::size_t length = strlen(ansiString);
 //				if (length > 0)
 //				{
-//					mString.reserve(length + 1);
-//					Utf32::FromAnsi(ansiString, ansiString + length, std::back_inserter(mString), locale);
+//				 m_String.reserve(length + 1);
+//					Utf32::FromAnsi(ansiString, ansiString + length, std::back_inserter(m_String), locale);
 //				}
 //			}
 //		}
@@ -56,8 +56,8 @@
 //		////////////////////////////////////////////////////////////
 //		String::String(const std::string& ansiString, const std::locale& locale)
 //		{
-//			mString.reserve(ansiString.length() + 1);
-//			Utf32::FromAnsi(ansiString.begin(), ansiString.end(), std::back_inserter(mString), locale);
+//		 m_String.reserve(ansiString.length() + 1);
+//			Utf32::FromAnsi(ansiString.begin(), ansiString.end(), std::back_inserter(m_String), locale);
 //		}
 //
 //
@@ -69,8 +69,8 @@
 //				std::size_t length = std::wcslen(wideString);
 //				if (length > 0)
 //				{
-//					mString.reserve(length + 1);
-//					Utf32::FromWide(wideString, wideString + length, std::back_inserter(mString));
+//				 m_String.reserve(length + 1);
+//					Utf32::FromWide(wideString, wideString + length, std::back_inserter(m_String));
 //				}
 //			}
 //		}
@@ -79,8 +79,8 @@
 //		////////////////////////////////////////////////////////////
 //		String::String(const std::wstring& wideString)
 //		{
-//			mString.reserve(wideString.length() + 1);
-//			Utf32::FromWide(wideString.begin(), wideString.end(), std::back_inserter(mString));
+//		 m_String.reserve(wideString.length() + 1);
+//			Utf32::FromWide(wideString.begin(), wideString.end(), std::back_inserter(m_String));
 //		}
 //
 //
@@ -88,20 +88,20 @@
 //		String::String(const uint32* utf32String)
 //		{
 //			if (utf32String)
-//				mString = utf32String;
+//			 m_String = utf32String;
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::String(const std::basic_string<uint32>& utf32String) :
-//			mString(utf32String)
+//		 m_String(utf32String)
 //		{
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::String(const String& copy) :
-//			mString(copy.mString)
+//		 m_String(copy.mString)
 //		{
 //		}
 //
@@ -125,10 +125,10 @@
 //		{
 //			// Prepare the output string
 //			std::string output;
-//			output.reserve(mString.length() + 1);
+//			output.reserve(m_String.length() + 1);
 //
 //			// Convert
-//			Utf32::ToAnsi(mString.begin(), mString.end(), std::back_inserter(output), 0, locale);
+//			Utf32::ToAnsi(m_String.begin(), m_String.end(), std::back_inserter(output), 0, locale);
 //
 //			return output;
 //		}
@@ -139,10 +139,10 @@
 //		{
 //			// Prepare the output string
 //			std::wstring output;
-//			output.reserve(mString.length() + 1);
+//			output.reserve(m_String.length() + 1);
 //
 //			// Convert
-//			Utf32::ToWide(mString.begin(), mString.end(), std::back_inserter(output), 0);
+//			Utf32::ToWide(m_String.begin(), m_String.end(), std::back_inserter(output), 0);
 //
 //			return output;
 //		}
@@ -153,10 +153,10 @@
 //		{
 //			// Prepare the output string
 //			std::basic_string<uint8> output;
-//			output.reserve(mString.length());
+//			output.reserve(m_String.length());
 //
 //			// Convert
-//			Utf32::ToUtf8(mString.begin(), mString.end(), std::back_inserter(output));
+//			Utf32::ToUtf8(m_String.begin(), m_String.end(), std::back_inserter(output));
 //
 //			return output;
 //		}
@@ -167,10 +167,10 @@
 //		{
 //			// Prepare the output string
 //			std::basic_string<uint16> output;
-//			output.reserve(mString.length());
+//			output.reserve(m_String.length());
 //
 //			// Convert
-//			Utf32::ToUtf16(mString.begin(), mString.end(), std::back_inserter(output));
+//			Utf32::ToUtf16(m_String.begin(), m_String.end(), std::back_inserter(output));
 //
 //			return output;
 //		}
@@ -179,14 +179,14 @@
 //		////////////////////////////////////////////////////////////
 //		std::basic_string<uint32> String::ToUtf32() const
 //		{
-//			return mString;
+//			return m_String;
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String& String::operator =(const String& right)
 //		{
-//			mString = right.mString;
+//		 m_String = right.mString;
 //			return *this;
 //		}
 //
@@ -194,7 +194,7 @@
 //		////////////////////////////////////////////////////////////
 //		String& String::operator +=(const String& right)
 //		{
-//			mString += right.mString;
+//		 m_String += right.mString;
 //			return *this;
 //		}
 //
@@ -202,63 +202,63 @@
 //		////////////////////////////////////////////////////////////
 //		uint32 String::operator [](std::size_t index) const
 //		{
-//			return mString[index];
+//			return m_String[index];
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		uint32& String::operator [](std::size_t index)
 //		{
-//			return mString[index];
+//			return m_String[index];
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		void String::Clear()
 //		{
-//			mString.clear();
+//		 m_String.clear();
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		std::size_t String::GetSize() const
 //		{
-//			return mString.size();
+//			return m_String.size();
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		bool String::IsEmpty() const
 //		{
-//			return mString.empty();
+//			return m_String.empty();
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		void String::Erase(std::size_t position, std::size_t count)
 //		{
-//			mString.erase(position, count);
+//		 m_String.erase(position, count);
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		void String::Insert(std::size_t position, const String& str)
 //		{
-//			mString.insert(position, str.mString);
+//		 m_String.insert(position, str.mString);
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		std::size_t String::Find(const String& str, std::size_t start) const
 //		{
-//			return mString.find(str.mString, start);
+//			return m_String.find(str.mString, start);
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		void String::Replace(std::size_t position, std::size_t length, const String& replaceWith)
 //		{
-//			mString.replace(position, length, replaceWith.mString);
+//		 m_String.replace(position, length, replaceWith.mString);
 //		}
 //
 //
@@ -281,42 +281,42 @@
 //		////////////////////////////////////////////////////////////
 //		String String::Substring(std::size_t position, std::size_t length) const
 //		{
-//			return mString.substr(position, length);
+//			return m_String.substr(position, length);
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		const uint32* String::GetData() const
 //		{
-//			return mString.c_str();
+//			return m_String.c_str();
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::Iterator String::Begin()
 //		{
-//			return mString.begin();
+//			return m_String.begin();
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::ConstIterator String::Begin() const
 //		{
-//			return mString.begin();
+//			return m_String.begin();
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::Iterator String::End()
 //		{
-//			return mString.end();
+//			return m_String.end();
 //		}
 //
 //
 //		////////////////////////////////////////////////////////////
 //		String::ConstIterator String::End() const
 //		{
-//			return mString.end();
+//			return m_String.end();
 //		}
 //
 //
diff --git a/source/modules/asura-core/font/string.hpp b/source/modules/asura-core/font/string.hpp
index 5a48eb7..2c6c845 100644
--- a/source/modules/asura-core/font/string.hpp
+++ b/source/modules/asura-core/font/string.hpp
@@ -500,7 +500,7 @@
 //			////////////////////////////////////////////////////////////
 //			// Member data
 //			////////////////////////////////////////////////////////////
-//			std::basic_string<uint> mString; ///< Internal string of UTF-32 characters
+//			std::basic_string<uint> m_String; ///< Internal string of UTF-32 characters
 //		};
 //
 //		////////////////////////////////////////////////////////////
diff --git a/source/modules/asura-core/graphics/binding/_gpu_buffer.cpp b/source/modules/asura-core/graphics/binding/_gpu_buffer.cpp
index f55ba64..785496e 100644
--- a/source/modules/asura-core/graphics/binding/_gpu_buffer.cpp
+++ b/source/modules/asura-core/graphics/binding/_gpu_buffer.cpp
@@ -68,7 +68,7 @@ namespace AsuraEngine
 			lua_rawgeti(L, 2, i);
 			while (!lua_isnil(L, -1))
 			{
-				switch (self->mDataType)
+				switch (self->m_DataType)
 				{
 					case GL_INT: 
 					{
@@ -104,14 +104,14 @@ namespace AsuraEngine
 		LUAX_IMPL_METHOD(GPUBuffer, _GetSize)
 		{
 			LUAX_PREPARE(L, GPUBuffer);
-			state.Push(self->mSize);
+			state.Push(self->m_Size);
 			return 0;
 		}
 
 		LUAX_IMPL_METHOD(GPUBuffer, _GetCount)
 		{
 			LUAX_PREPARE(L, GPUBuffer);
-			state.Push(self->mSize / self->GetDataTypeSize());
+			state.Push(self->m_Size / self->GetDataTypeSize());
 			return 0;
 		}
 
diff --git a/source/modules/asura-core/graphics/binding/_texture.cpp b/source/modules/asura-core/graphics/binding/_texture.cpp
index 489d362..305ac22 100644
--- a/source/modules/asura-core/graphics/binding/_texture.cpp
+++ b/source/modules/asura-core/graphics/binding/_texture.cpp
@@ -61,8 +61,8 @@ namespace AsuraEngine
 		LUAX_IMPL_METHOD(Texture, _GetFilterMode)
 		{
 			LUAX_PREPARE(L, Texture);
-			state.Push((int)self->mMinFilter);
-			state.Push((int)self->mMagFilter);
+			state.Push((int)self->m_MinFilter);
+			state.Push((int)self->m_MagFilter);
 			return 2;
 		}
 
@@ -70,7 +70,7 @@ namespace AsuraEngine
 		LUAX_IMPL_METHOD(Texture, _GetWrapMode)
 		{
 			LUAX_PREPARE(L, Texture);
-			state.Push((int)self->mWrapMode);
+			state.Push((int)self->m_WrapMode);
 			return 1;
 		}
 
diff --git a/source/modules/asura-core/graphics/canvas.cpp b/source/modules/asura-core/graphics/canvas.cpp
index 0a17085..e922a51 100644
--- a/source/modules/asura-core/graphics/canvas.cpp
+++ b/source/modules/asura-core/graphics/canvas.cpp
@@ -6,42 +6,42 @@ namespace AsuraEngine
 	{
 
 		Canvas::Canvas()
-			: mWidth(0)
-			, mHeight(0)
-			, mFBO(0)
+			: m_Width(0)
+			, m_Height(0)
+			, m_FBO(0)
 		{
 			// Fix: �����ô�С��ʼ��ʱ������framebuffer��Դ��
-			//glGenFramebuffers(1, &mFBO);
+			//glGenFramebuffers(1, &m_FBO);
 			//GLint current_fbo;
 			//glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &current_fbo);
-			//glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-			//glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTexID, 0);
+			//glBindFramebuffer(GL_FRAMEBUFFER, m_FBO);
+			//glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_TexID, 0);
 			//glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
 		}
 
 		void Canvas::SetSize(uint w, uint h)
 		{
-			if (mFBO == 0)
+			if (m_FBO == 0)
 			{
-				glGenFramebuffers(1, &mFBO);
-				if (mFBO == 0)
+				glGenFramebuffers(1, &m_FBO);
+				if (m_FBO == 0)
 					throw Exception("OpenGL glGenFramebuffers cannot generate frame buffer object.");
 				// ��������
-				if (mTexID == 0)
+				if (m_TexID == 0)
 				{
-					glGenTextures(1, &mTexID);
-					if (mTexID == 0)
+					glGenTextures(1, &m_TexID);
+					if (m_TexID == 0)
 						throw Exception("OpenGL glGenTextures cannot generate texture.");
 				}
 				GLint current_fbo;
 				glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &current_fbo);
-				glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTexID, 0);
+				glBindFramebuffer(GL_FRAMEBUFFER, m_FBO);
+				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_TexID, 0);
 				glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
 			}
 			GLint current_tex; 
 			glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_tex);
-			glBindTexture(GL_TEXTURE_2D, mTexID);
+			glBindTexture(GL_TEXTURE_2D, m_TexID);
 			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 			glBindTexture(GL_TEXTURE_2D, current_tex);
 		}
diff --git a/source/modules/asura-core/graphics/canvas.h b/source/modules/asura-core/graphics/canvas.h
index e2e713c..332e973 100644
--- a/source/modules/asura-core/graphics/canvas.h
+++ b/source/modules/asura-core/graphics/canvas.h
@@ -47,11 +47,11 @@ namespace AsuraEngine
 
 		private:
 
-			GLuint mFBO;
+			GLuint m_FBO;
 
-			GLuint mTexID;
+			GLuint m_TexID;
 
-			uint mWidth, mHeight;
+			uint m_Width, m_Height;
 
 		luaxport:
 
diff --git a/source/modules/asura-core/graphics/gpu_buffer.cpp b/source/modules/asura-core/graphics/gpu_buffer.cpp
index 8d6f491..4d59009 100644
--- a/source/modules/asura-core/graphics/gpu_buffer.cpp
+++ b/source/modules/asura-core/graphics/gpu_buffer.cpp
@@ -6,26 +6,26 @@ namespace AsuraEngine
 	{
 
 		GPUBuffer::GPUBuffer(BufferType type, BufferUsage usage, BufferDataType dataType, size_t size)
-			: mTarget(GL_ZERO)
-			, mBuffer(GL_ZERO)
-			, mSize(0)
+			: m_Target(GL_ZERO)
+			, m_Buffer(GL_ZERO)
+			, m_Size(0)
 #if ASURA_DEBUG 
-			, mData(nullptr)
+			, m_Data(nullptr)
 #endif
 		{
-			mTarget = ConvertBufferType(type);
-			mUsage = ConvertBufferUsage(usage);
-			mDataType = ConvertBufferDataType(dataType);
-			mSize = size;
+		 m_Target = ConvertBufferType(type);
+		 m_Usage = ConvertBufferUsage(usage);
+		 m_DataType = ConvertBufferDataType(dataType);
+		 m_Size = size;
 		}
 
 		GPUBuffer::~GPUBuffer()
 		{
 #if ASURA_DEBUG 
-			if (mData)
-				free(mData);
+			if (m_Data)
+				free(m_Data);
 #endif
-			glDeleteBuffers(1, &mBuffer);
+			glDeleteBuffers(1, &m_Buffer);
 		}
 
 		GLenum GPUBuffer::ConvertBufferType(BufferType type)
@@ -69,63 +69,63 @@ namespace AsuraEngine
 		{
 			if (data == nullptr)
 				return false;
-			if (mBuffer == 0)
+			if (m_Buffer == 0)
 			{
 				gfx.WipeError();
-				glGenBuffers(1, &mBuffer);
-				if (mBuffer == 0)
+				glGenBuffers(1, &m_Buffer);
+				if (m_Buffer == 0)
 					throw Exception("OpenGL glGenBuffers failed.");
-				glBindBuffer(mTarget, mBuffer);
-				glBufferData(mTarget, mSize, NULL, mUsage);
+				glBindBuffer(m_Target, m_Buffer);
+				glBufferData(m_Target, m_Size, NULL, m_Usage);
 				if (gfx.HasError())
 				{
-					glBindBuffer(mTarget, 0);
+					glBindBuffer(m_Target, 0);
 					throw Exception("OpenGL glBufferData failed. Errorcode=%d.", gfx.GetError());
 				}
 #if ASURA_DEBUG 
-				mData = (byte*)malloc(size);
-				memset(mData, 0, size);
+			 m_Data = (byte*)malloc(size);
+				memset(m_Data, 0, size);
 #endif
 			}
 			else
-				glBindBuffer(mTarget, mBuffer);
-			glBufferSubData(mTarget, offset, size, data);
+				glBindBuffer(m_Target, m_Buffer);
+			glBufferSubData(m_Target, offset, size, data);
 			if (gfx.HasError())
 			{
-				glBindBuffer(mTarget, 0);
+				glBindBuffer(m_Target, 0);
 				throw Exception("OpenGL glBufferSubData failed. Errorcode=%d.", gfx.GetError());
 			}
-			glBindBuffer(mTarget, 0);
+			glBindBuffer(m_Target, 0);
 #if ASURA_DEBUG
-			memcpy(mData + offset, data, size);
+			memcpy(m_Data + offset, data, size);
 #endif
 			return true;
 		}
 
 		void GPUBuffer::Bind()
 		{
-			glBindBuffer(mTarget, mBuffer);
+			glBindBuffer(m_Target, m_Buffer);
 		}
 		
 		void GPUBuffer::UnBind()
 		{
-			glBindBuffer(mTarget, 0);
+			glBindBuffer(m_Target, 0);
 		}
 
 		uint GPUBuffer::GetBufferSize()
 		{
-			return mSize; 
+			return m_Size; 
 		}
 
 		GLenum GPUBuffer::GetDataType()
 		{
-			return mDataType;
+			return m_DataType;
 		}
 
 		size_t GPUBuffer::GetDataTypeSize()
 		{
 			//https://blog.csdn.net/nklinux/article/details/16919017
-			switch (mDataType)
+			switch (m_DataType)
 			{
 			case GL_UNSIGNED_BYTE: 
 				return sizeof(GLbyte); 
diff --git a/source/modules/asura-core/graphics/gpu_buffer.h b/source/modules/asura-core/graphics/gpu_buffer.h
index f759c16..09c5476 100644
--- a/source/modules/asura-core/graphics/gpu_buffer.h
+++ b/source/modules/asura-core/graphics/gpu_buffer.h
@@ -61,20 +61,20 @@ namespace AsuraEngine
 			GLenum ConvertBufferUsage(BufferUsage type);
 			GLenum ConvertBufferDataType(BufferDataType type);
 
-			GLenum mTarget;
-			GLuint mBuffer;
+			GLenum m_Target;
+			GLuint m_Buffer;
 			///
 			/// opengl���Դ滺�岢û�ж��������͵�Ҫ��ֻ��glVertexAttribPointerʱ��ָ��������
 			/// drawcall ʱ���ݸ�����������ʼ��ַ�����ʹ�buffer��ȡ���ඥ�����ݣ����Բ�ͬ����������
 			/// ���Ա�����һ��buffer�С�����Ϊ�˱��ֽӿڵļ�࣬�����ڳ�ʼ��bufferʱָ�����������
 			/// ���ͣ��������������ڱ����������͵�һ�£����Բ�ͬ���������ͷ�����ͬ��buffer��
 			///
-			GLenum mDataType;
-			GLuint mUsage;
-			uint   mSize;
+			GLenum m_DataType;
+			GLuint m_Usage;
+			uint   m_Size;
 
 #if ASURA_DEBUG
-			byte* mData; 
+			byte* m_Data; 
 #endif
 
 		luaxport:
diff --git a/source/modules/asura-core/graphics/image.cpp b/source/modules/asura-core/graphics/image.cpp
index 1d74d27..a0dff8d 100644
--- a/source/modules/asura-core/graphics/image.cpp
+++ b/source/modules/asura-core/graphics/image.cpp
@@ -15,8 +15,8 @@ namespace AsuraEngine
 	{
 
 		Image::Image()
-			: mWidth(0)
-			, mHeight(0)
+			: m_Width(0)
+			, m_Height(0)
 		{
 		}
 
@@ -28,14 +28,14 @@ namespace AsuraEngine
 		{
 			if (!imgData) return false; 
 
-			if (mTexID == 0)
+			if (m_TexID == 0)
 			{
-				glGenTextures(1, &mTexID);
-				if (mTexID == 0)
+				glGenTextures(1, &m_TexID);
+				if (m_TexID == 0)
 					throw Exception("OpenGL glGenTextures failed.");
 			}
 
-			glBindTexture(GL_TEXTURE_2D, mTexID);
+			glBindTexture(GL_TEXTURE_2D, m_TexID);
 			imgData->Lock();
 			int width = imgData->width;
 			int height = imgData->height;
@@ -51,8 +51,8 @@ namespace AsuraEngine
 				, imgData->pixels
 			);
 
-			mWidth = imgData->width; 
-			mHeight = imgData->height;
+		 m_Width = imgData->width; 
+		 m_Height = imgData->height;
 			imgData->Unlock();
 			GLenum err = glGetError(); 
 			if (err != GL_NO_ERROR)
@@ -66,7 +66,7 @@ namespace AsuraEngine
 		{
 			if (!imgData) return false;
 
-			glBindTexture(GL_TEXTURE_2D, mTexID);
+			glBindTexture(GL_TEXTURE_2D, m_TexID);
 			imgData->Lock();
 			int width = imgData->width;
 			int height = imgData->height;
@@ -93,12 +93,12 @@ namespace AsuraEngine
 
 		uint32 Image::GetWidth()
 		{
-			return mWidth;
+			return m_Width;
 		}
 
 		uint32 Image::GetHeight()
 		{
-			return mHeight;
+			return m_Height;
 		}
 
 	} // Graphics 
diff --git a/source/modules/asura-core/graphics/image.h b/source/modules/asura-core/graphics/image.h
index d7cd37f..229a849 100644
--- a/source/modules/asura-core/graphics/image.h
+++ b/source/modules/asura-core/graphics/image.h
@@ -41,7 +41,7 @@ namespace AsuraEngine
 
 		private:
 
-			uint32 mWidth, mHeight;
+			uint32 m_Width, m_Height;
 
 		luaxport:
 
diff --git a/source/modules/asura-core/graphics/matrix_stack.cpp b/source/modules/asura-core/graphics/matrix_stack.cpp
index d48a1e0..2211158 100644
--- a/source/modules/asura-core/graphics/matrix_stack.cpp
+++ b/source/modules/asura-core/graphics/matrix_stack.cpp
@@ -9,7 +9,7 @@ namespace AsuraEngine
 			: top(0)
 		{
 			// ջ���������ʼ����ջ�������ô˱�֤ջ��Զ�ǿգ�������ȡֵ��
-			mStack[top].SetIdentity();
+		 m_Stack[top].SetIdentity();
 		}
 
 		MatrixStack::~MatrixStack()
@@ -18,7 +18,7 @@ namespace AsuraEngine
 
 		void MatrixStack::LoadIdentity()
 		{
-			mStack[top].SetIdentity();
+		 m_Stack[top].SetIdentity();
 		}
 
 		bool MatrixStack::Push()
@@ -26,7 +26,7 @@ namespace AsuraEngine
 			if (top == ASURA_MAX_MATRIX_STACK_DEPTH - 1)
 				return false;
 			++top; 
-			mStack[top] = mStack[top - 1];
+		 m_Stack[top] = m_Stack[top - 1];
 			return true;
 		}
 
@@ -40,7 +40,7 @@ namespace AsuraEngine
 
 		AEMath::Matrix44& MatrixStack::GetTop()
 		{
-			return mStack[top];
+			return m_Stack[top];
 		}
 
 		uint MatrixStack::GetTopIndex()
@@ -55,22 +55,22 @@ namespace AsuraEngine
 
 		void MatrixStack::Ortho(float left, float right, float bottom, float top, float near, float far)
 		{
-			mStack[this->top].Ortho(left, right, bottom, top, near, far);
+		 m_Stack[this->top].Ortho(left, right, bottom, top, near, far);
 		}
 
 		void MatrixStack::Rotate(float angle)
 		{
-			mStack[top].Rotate(angle);
+		 m_Stack[top].Rotate(angle);
 		}
 
 		void MatrixStack::Translate(float x, float y)
 		{
-			mStack[top].Translate(x, y);
+		 m_Stack[top].Translate(x, y);
 		}
 
 		void MatrixStack::Scale(float x, float y)
 		{
-			mStack[top].Scale(x, y);
+		 m_Stack[top].Scale(x, y);
 		}
 
 	}
diff --git a/source/modules/asura-core/graphics/matrix_stack.h b/source/modules/asura-core/graphics/matrix_stack.h
index ae983e7..67401d0 100644
--- a/source/modules/asura-core/graphics/matrix_stack.h
+++ b/source/modules/asura-core/graphics/matrix_stack.h
@@ -48,7 +48,7 @@ namespace AsuraEngine
 
 		private: 
 
-			AEMath::Matrix44 mStack[ASURA_MAX_MATRIX_STACK_DEPTH];
+			AEMath::Matrix44 m_Stack[ASURA_MAX_MATRIX_STACK_DEPTH];
 			uint8            top;
 
 		};
diff --git a/source/modules/asura-core/graphics/mesh2d.h b/source/modules/asura-core/graphics/mesh2d.h
index 5330967..8c26564 100644
--- a/source/modules/asura-core/graphics/mesh2d.h
+++ b/source/modules/asura-core/graphics/mesh2d.h
@@ -37,8 +37,8 @@ namespace AsuraEngine
 
 		private: 
 
-			VertexBuffer* mVBO; ///< vertex buffer 
-			IndexBuffer*  mIBO; ///< index buffer 
+			VertexBuffer* m_VBO; ///< vertex buffer 
+			IndexBuffer*  m_IBO; ///< index buffer 
 
 		luaxport: 
 
diff --git a/source/modules/asura-core/graphics/shader.cpp b/source/modules/asura-core/graphics/shader.cpp
index 22b9ee3..8606e79 100644
--- a/source/modules/asura-core/graphics/shader.cpp
+++ b/source/modules/asura-core/graphics/shader.cpp
@@ -19,9 +19,9 @@ namespace AsuraEngine
 
 		Shader::~Shader()
 		{
-			if(mVertShader) glDeleteShader(mVertShader);
-			if(mFragShader) glDeleteShader(mFragShader);
-			if(mProgram) glDeleteProgram(mProgram);
+			if(m_VertShader) glDeleteShader(m_VertShader);
+			if(m_FragShader) glDeleteShader(m_FragShader);
+			if(m_Program) glDeleteProgram(m_Program);
 		}
 
 		void Shader::SetActive(Shader* shader)
@@ -38,10 +38,10 @@ namespace AsuraEngine
 		{
 			string warnning = "";
 
-			if (!mProgram)
+			if (!m_Program)
 			{
-				mProgram = glCreateProgram();
-				if (!mProgram)
+			 m_Program = glCreateProgram();
+				if (!m_Program)
 					throw Exception("Cannot create OpenGL shader program.");
 			}
 
@@ -55,12 +55,12 @@ namespace AsuraEngine
 				throw Exception("Compile fragment shader failed:%s", warnning);
 			}
 
-			glAttachShader(mProgram, mVertShader);
-			glAttachShader(mProgram, mFragShader);
+			glAttachShader(m_Program, m_VertShader);
+			glAttachShader(m_Program, m_FragShader);
 
-			glLinkProgram(mProgram);
+			glLinkProgram(m_Program);
 			GLint success;
-			glGetProgramiv(mProgram, GL_LINK_STATUS, &success);
+			glGetProgramiv(m_Program, GL_LINK_STATUS, &success);
 			if (success == GL_FALSE)
 			{
 				warnning = GetProgramWarnings();
@@ -72,10 +72,10 @@ namespace AsuraEngine
 
 		bool Shader::CompileVertexShader(const string& vert, string& outError)
 		{
-			if (!mVertShader)
+			if (!m_VertShader)
 			{
-				mVertShader = glCreateShader(GL_VERTEX_SHADER);
-				if (!mVertShader)
+			 m_VertShader = glCreateShader(GL_VERTEX_SHADER);
+				if (!m_VertShader)
 				{
 					outError = "Cannot create OpenGL Vertex shader.";
 					return false;
@@ -85,12 +85,12 @@ namespace AsuraEngine
 			const GLchar* source = vert.c_str();
 			GLint success;
 
-			glShaderSource(mVertShader, 1, &source, NULL);
-			glCompileShader(mVertShader);
-			glGetShaderiv(mVertShader, GL_COMPILE_STATUS, &success);
+			glShaderSource(m_VertShader, 1, &source, NULL);
+			glCompileShader(m_VertShader);
+			glGetShaderiv(m_VertShader, GL_COMPILE_STATUS, &success);
 			if (success == GL_FALSE)
 			{
-				outError = GetShaderWarnings(mVertShader);
+				outError = GetShaderWarnings(m_VertShader);
 				return false; 
 			}
 
@@ -99,10 +99,10 @@ namespace AsuraEngine
 
 		bool Shader::CompileFragementShader(const string& frag, string& outError)
 		{
-			if (!mFragShader)
+			if (!m_FragShader)
 			{
-				mFragShader = glCreateShader(GL_FRAGMENT_SHADER);
-				if (!mFragShader)
+			 m_FragShader = glCreateShader(GL_FRAGMENT_SHADER);
+				if (!m_FragShader)
 				{
 					outError = "Cannot create OpenGL fragment shader.";
 					return false; 
@@ -113,12 +113,12 @@ namespace AsuraEngine
 			GLint success;
 
 			source = frag.c_str();
-			glShaderSource(mFragShader, 1, &source, NULL);
-			glCompileShader(mFragShader);
-			glGetShaderiv(mFragShader, GL_COMPILE_STATUS, &success);
+			glShaderSource(m_FragShader, 1, &source, NULL);
+			glCompileShader(m_FragShader);
+			glGetShaderiv(m_FragShader, GL_COMPILE_STATUS, &success);
 			if (success == GL_FALSE)
 			{
-				outError = GetShaderWarnings(mFragShader);
+				outError = GetShaderWarnings(m_FragShader);
 				return false;
 			}
 
@@ -142,19 +142,19 @@ namespace AsuraEngine
 
 		uint Shader::GetUniformLocation(const std::string& uniform)
 		{
-			GLint loc = glGetUniformLocation(mProgram, uniform.c_str());
+			GLint loc = glGetUniformLocation(m_Program, uniform.c_str());
 			return loc;
 		}
 
 		bool Shader::HasUniform(const std::string& uniform)
 		{
-			GLint loc = glGetUniformLocation(mProgram, uniform.c_str());
+			GLint loc = glGetUniformLocation(m_Program, uniform.c_str());
 			return loc != -1;
 		}
 
 		GLuint Shader::GetGLProgram()
 		{
-			return mProgram;
+			return m_Program;
 		}
 
 		void Shader::SetUniformFloat(uint loc, float value)
@@ -222,7 +222,7 @@ namespace AsuraEngine
 		std::string Shader::GetProgramWarnings()
 		{
 			GLint strsize, nullpos;
-			glGetProgramiv(mProgram, GL_INFO_LOG_LENGTH, &strsize);
+			glGetProgramiv(m_Program, GL_INFO_LOG_LENGTH, &strsize);
 
 			if (strsize == 0)
 				return "";
@@ -230,7 +230,7 @@ namespace AsuraEngine
 			char *tempstr = new char[strsize];
 
 			memset(tempstr, '\0', strsize);
-			glGetProgramInfoLog(mProgram, strsize, &nullpos, tempstr);
+			glGetProgramInfoLog(m_Program, strsize, &nullpos, tempstr);
 			tempstr[nullpos] = '\0';
 
 			std::string warnings(tempstr);
@@ -271,7 +271,7 @@ namespace AsuraEngine
 
 		int Shader::GetAttributeLocation(const std::string& attribute)
 		{
-			int loc = glGetAttribLocation(mProgram, attribute.c_str());
+			int loc = glGetAttribLocation(m_Program, attribute.c_str());
 			return loc;
 		}
 
diff --git a/source/modules/asura-core/graphics/shader.h b/source/modules/asura-core/graphics/shader.h
index 30a386e..dc8dbe0 100644
--- a/source/modules/asura-core/graphics/shader.h
+++ b/source/modules/asura-core/graphics/shader.h
@@ -83,9 +83,9 @@ namespace AsuraEngine
 			std::string GetProgramWarnings();
 			std::string GetShaderWarnings(GLuint shader);
 
-			GLuint mProgram;
-			GLuint mVertShader;
-			GLuint mFragShader;
+			GLuint m_Program;
+			GLuint m_VertShader;
+			GLuint m_FragShader;
 
 		luaxport: 
 
diff --git a/source/modules/asura-core/graphics/texture.cpp b/source/modules/asura-core/graphics/texture.cpp
index 240a5f8..ef85ceb 100644
--- a/source/modules/asura-core/graphics/texture.cpp
+++ b/source/modules/asura-core/graphics/texture.cpp
@@ -8,20 +8,20 @@ namespace AsuraEngine
 	{
 
 		Texture::Texture()
-			: mTexID(0)
+			: m_TexID(0)
 		{
 		}
 
 		Texture::~Texture()
 		{
 			// �ͷ�������Դ
-			if(mTexID != 0)
-				glDeleteTextures(1, &mTexID);
+			if(m_TexID != 0)
+				glDeleteTextures(1, &m_TexID);
 		}
 
 		GLuint Texture::GetGLTexture() const
 		{
-			return mTexID;
+			return m_TexID;
 		}
 
 		TextureFormat Texture::ConvertColorFormat(const ColorFormat& colorformat)
diff --git a/source/modules/asura-core/graphics/texture.h b/source/modules/asura-core/graphics/texture.h
index e16990c..5d754eb 100644
--- a/source/modules/asura-core/graphics/texture.h
+++ b/source/modules/asura-core/graphics/texture.h
@@ -77,11 +77,11 @@ namespace AsuraEngine
 			/// ת��color formatΪtexture format��
 			TextureFormat ConvertColorFormat(const ColorFormat& colorformat);
 
-			GLuint     mTexID;
-			FilterMode mMinFilter;
-			FilterMode mMagFilter;
-			WrapMode   mWrapMode;
-			bool       mIsGenMipmap;
+			GLuint     m_TexID;
+			FilterMode m_MinFilter;
+			FilterMode m_MagFilter;
+			WrapMode   m_WrapMode;
+			bool       m_IsGenMipmap;
 
 			LUAX_DECL_ENUM(ColorFormat, 1);
 			LUAX_DECL_ENUM(FilterMode, 1);
diff --git a/source/modules/asura-core/image/image_data.cpp b/source/modules/asura-core/image/image_data.cpp
index b35c4b2..883343c 100644
--- a/source/modules/asura-core/image/image_data.cpp
+++ b/source/modules/asura-core/image/image_data.cpp
@@ -52,12 +52,12 @@ namespace AsuraEngine
 
 		void ImageData::Lock()
 		{
-			mMutex.Lock();
+		 m_Mutex.Lock();
 		}
 
 		void ImageData::Unlock()
 		{
-			mMutex.Unlock();
+		 m_Mutex.Unlock();
 		}
 		
 	}
diff --git a/source/modules/asura-core/image/image_data.h b/source/modules/asura-core/image/image_data.h
index ca459e7..8b4f04a 100644
--- a/source/modules/asura-core/image/image_data.h
+++ b/source/modules/asura-core/image/image_data.h
@@ -57,7 +57,7 @@ namespace AsuraEngine
 			///
 			/// д���ݵ�����
 			///
-			AEThreading::Mutex mMutex;
+			AEThreading::Mutex m_Mutex;
 		
 		luaxport:
 
diff --git a/source/modules/asura-core/mesh/mesh2d_data.h b/source/modules/asura-core/mesh/mesh2d_data.h
index cd7c9ee..2fea7ec 100644
--- a/source/modules/asura-core/mesh/mesh2d_data.h
+++ b/source/modules/asura-core/mesh/mesh2d_data.h
@@ -61,14 +61,14 @@ namespace AsuraEngine
 			///
 			/// mesh�����ж��㡣
 			///
-			std::vector<Vertex*> mVertices;
+			std::vector<Vertex*> m_Vertices;
 
 			///
 			/// ��������������ebo��
 			///
-			std::vector<int> mIndices;
+			std::vector<int> m_Indices;
 
-			int mComponents;
+			int m_Components;
 
 		};
 
diff --git a/source/modules/asura-core/threading/thread_ex.h b/source/modules/asura-core/threading/thread_ex.h
index 9f63034..9678647 100644
--- a/source/modules/asura-core/threading/thread_ex.h
+++ b/source/modules/asura-core/threading/thread_ex.h
@@ -39,12 +39,12 @@ namespace AsuraEngine
 			///
 			void RegisterModules();
 
-			ThreadImpl* mImpl;
+			ThreadImpl* m_Impl;
 
 			///
 			/// �̴߳������������
 			///
-			Luax::LuaxVM* mVM;
+			Luax::LuaxVM* m_VM;
 
 		};
 
diff --git a/source/modules/asura-core/window/window.cpp b/source/modules/asura-core/window/window.cpp
index 9dc247d..939e974 100644
--- a/source/modules/asura-core/window/window.cpp
+++ b/source/modules/asura-core/window/window.cpp
@@ -12,93 +12,93 @@ namespace AsuraEngine
 	{
 
 		Window::Window()
-			: mImpl(nullptr)
+			: m_Impl(nullptr)
 		{
 		}
 
 		Window::~Window()
 		{
-			if (mImpl)
-				delete mImpl;
+			if (m_Impl)
+				delete m_Impl;
 		}
 
 #define try_init_window(impl)			\
-			if (!mImpl)									\
+			if (!m_Impl)									\
 			{														\
-				mImpl = new impl();				\
-				if (!mImpl->Init(config))	\
+			 m_Impl = new impl();				\
+				if (!m_Impl->Init(config))	\
 				{													\
-					delete mImpl;						\
-					mImpl = nullptr;				\
+					delete m_Impl;						\
+				 m_Impl = nullptr;				\
 				}													\
 			}
 
 		bool Window::Init(const WindowConfig& config)
 		{
-			ASSERT(!mImpl);
+			ASSERT(!m_Impl);
 #if ASURA_WINDOW_SDL
 			try_init_window(WindowImplSDL);
 #endif
-			return mImpl != nullptr;
+			return m_Impl != nullptr;
 		}
 
 		void Window::Exit()
 		{
-			if (mImpl)
-				delete mImpl;
+			if (m_Impl)
+				delete m_Impl;
 		}
 
 		void Window::SetPosition(int x, int y)
 		{
-			ASSERT(mImpl);
-			mImpl->SetPosition(x, y);
+			ASSERT(m_Impl);
+		 m_Impl->SetPosition(x, y);
 		}
 
 		void Window::SetTitle(const std::string& title)
 		{
-			ASSERT(mImpl);
-			mImpl->SetTitils(title);
+			ASSERT(m_Impl);
+		 m_Impl->SetTitils(title);
 		}
 
 		void Window::Show()
 		{
-			ASSERT(mImpl);
-			mImpl->Show();
+			ASSERT(m_Impl);
+		 m_Impl->Show();
 		}
 
 		void Window::Hide()
 		{
-			ASSERT(mImpl);
-			mImpl->Hide();
+			ASSERT(m_Impl);
+		 m_Impl->Hide();
 		}
 
 		void Window::SwapRenderBuffer()
 		{
-			ASSERT(mImpl);
-			mImpl->SwapRenderBuffer();
+			ASSERT(m_Impl);
+		 m_Impl->SwapRenderBuffer();
 		}
 
 		void Window::Clear(const AEGraphics::Color& col /*= AEGraphics::Color::Black*/)
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 			glClearColor(col.r, col.g, col.b, col.a);
 		}
 
 		//void Window::Clear(const Math::Recti& quad, const AEGraphics::Color& col /*= AEGraphics::Color::Black*/)
 		//{
-		//	ASSERT(mImpl);
+		//	ASSERT(m_Impl);
 
 		//}
 
 		void Window::Draw(const AEGraphics::Drawable* texture, const AEGraphics::RenderState& state)
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 		}
 /*
 		void Window::Draw(const AEGraphics::Drawable* texture, const Math::Recti& quad, const AEGraphics::RenderState& state)
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 		}
 */
diff --git a/source/modules/asura-core/window/window.h b/source/modules/asura-core/window/window.h
index 835535d..deffc10 100644
--- a/source/modules/asura-core/window/window.h
+++ b/source/modules/asura-core/window/window.h
@@ -90,7 +90,7 @@ namespace AsuraEngine
 
 		private:
 
-			WindowImpl* mImpl;
+			WindowImpl* m_Impl;
 
 		luaxport: 
 
diff --git a/source/modules/asura-core/window/window_impl_sdl.cpp b/source/modules/asura-core/window/window_impl_sdl.cpp
index 2679bc1..29a7540 100644
--- a/source/modules/asura-core/window/window_impl_sdl.cpp
+++ b/source/modules/asura-core/window/window_impl_sdl.cpp
@@ -21,15 +21,15 @@ namespace AsuraEngine
 			flag |= _sdl_flag
 
 		WindowImplSDL::WindowImplSDL()
-			: mWnd(nullptr)
-			, mGLContext(0)
+			: m_Wnd(nullptr)
+			, m_GLContext(0)
 		{
 		}
 
 		WindowImplSDL::~WindowImplSDL()
 		{
-			SDL_GL_DeleteContext(mGLContext);
-			SDL_DestroyWindow(mWnd);
+			SDL_GL_DeleteContext(m_GLContext);
+			SDL_DestroyWindow(m_Wnd);
 			SDL_FlushEvent(SDL_WINDOWEVENT);
 		}
 
@@ -65,9 +65,9 @@ namespace AsuraEngine
 			SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 			SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 0);
 
-			mWnd = SDL_CreateWindow(config.title.c_str(), config.x, config.y, config.width, config.height, flag);
+		 m_Wnd = SDL_CreateWindow(config.title.c_str(), config.x, config.y, config.width, config.height, flag);
 
-			if (!mWnd)
+			if (!m_Wnd)
 				return false;
 
 			// ����ͼ��
@@ -96,7 +96,7 @@ namespace AsuraEngine
 
 						img->Unlock();
 
-						SDL_SetWindowIcon(mWnd, surface);
+						SDL_SetWindowIcon(m_Wnd, surface);
 						SDL_FreeSurface(surface);
 					}
 				}
@@ -105,15 +105,15 @@ namespace AsuraEngine
 			{
 			}
 
-			mGLContext = SDL_GL_CreateContext(mWnd);
+		 m_GLContext = SDL_GL_CreateContext(m_Wnd);
 
-			if (!mGLContext)
+			if (!m_GLContext)
 			{
-				SDL_DestroyWindow(mWnd);
+				SDL_DestroyWindow(m_Wnd);
 				return false;
 			}
 
-			SDL_GL_MakeCurrent(mWnd, mGLContext);
+			SDL_GL_MakeCurrent(m_Wnd, m_GLContext);
 			SDL_GL_SetSwapInterval(config.vsync ? 1 : 0);
 
 			return true;
@@ -121,32 +121,32 @@ namespace AsuraEngine
 
 		void WindowImplSDL::SetSize(uint width, uint height)
 		{
-			SDL_SetWindowSize(mWnd, width, height);
+			SDL_SetWindowSize(m_Wnd, width, height);
 		}
 
 		void WindowImplSDL::SetPosition(int x, int y)
 		{
-			SDL_SetWindowPosition(mWnd, x, y);
+			SDL_SetWindowPosition(m_Wnd, x, y);
 		}
 
 		void WindowImplSDL::SetTitils(const std::string& title)
 		{
-			SDL_SetWindowTitle(mWnd, title.c_str());
+			SDL_SetWindowTitle(m_Wnd, title.c_str());
 		}
 
 		void WindowImplSDL::Show()
 		{
-			SDL_ShowWindow(mWnd);
+			SDL_ShowWindow(m_Wnd);
 		}
 
 		void WindowImplSDL::Hide()
 		{
-			SDL_HideWindow(mWnd);
+			SDL_HideWindow(m_Wnd);
 		}
 
 		void WindowImplSDL::SwapRenderBuffer()
 		{
-			SDL_GL_SwapWindow(mWnd);
+			SDL_GL_SwapWindow(m_Wnd);
 		}
 
 	}
diff --git a/source/modules/asura-core/window/window_impl_sdl.h b/source/modules/asura-core/window/window_impl_sdl.h
index de4cafb..1f4ea0e 100644
--- a/source/modules/asura-core/window/window_impl_sdl.h
+++ b/source/modules/asura-core/window/window_impl_sdl.h
@@ -34,8 +34,8 @@ namespace AsuraEngine
 
 		private: 
 
-			SDL_Window* mWnd;
-			SDL_GLContext mGLContext;
+			SDL_Window* m_Wnd;
+			SDL_GLContext m_GLContext;
 
 		};