Move Log to core and switch to lowercase convention

src/ArchiveResourceArchive.cpp

@@ -47,9 +47,9 @@ ArchiveResourceArchive::ArchiveResourceArchive(Filesystem& fs) :
 	// Read the header of the archive
 	m_archive_file->read(&header, sizeof(ArchiveHeader));
 	
-	Log::D("Version: %d", header.version);
-	Log::D("Entries: %d", header.entries_count);
-	Log::D("Checksum: %d", header.checksum);
+	Log::d("Version: %d", header.version);
+	Log::d("Entries: %d", header.entries_count);
+	Log::d("Checksum: %d", header.checksum);
 	
 	m_entries = new ArchiveEntry[header.entries_count];
 	m_entries_count = header.entries_count;

src/CMakeLists.txt

@@ -5,7 +5,6 @@ set (SRC
 	Filesystem.cpp
 	Font.cpp
 	Image.cpp
-	Log.cpp
 	MaterialResource.cpp
 	MovableCamera.cpp
 	Pixel.cpp
@@ -34,7 +33,6 @@ set (HEADERS
 	Font.h
 	Glyph.h
 	Image.h
-	Log.h
 	MaterialResource.h
 	MovableCamera.h
 	Pixel.h
@@ -55,11 +53,13 @@ set (HEADERS
 )
 
 set (CORE_SRC
+	core/Log.cpp
 )
 
 set (CORE_HEADERS
 	core/Types.h
 	core/Args.h
+	core/Log.h
 )
 
 set (BV_SRC

src/Device.cpp

@@ -89,7 +89,7 @@ bool Device::init(int argc, char** argv)
 {
 	if (is_init())
 	{
-		Log::E("Crown Engine is already initialized.");
+		Log::e("Crown Engine is already initialized.");
 		return false;
 	}
 
@@ -99,7 +99,7 @@ bool Device::init(int argc, char** argv)
 	}
 
 	// Initialize
-	Log::I("Initializing Crown Engine %d.%d.%d...", CROWN_VERSION_MAJOR, CROWN_VERSION_MINOR, CROWN_VERSION_MICRO);
+	Log::i("Initializing Crown Engine %d.%d.%d...", CROWN_VERSION_MAJOR, CROWN_VERSION_MINOR, CROWN_VERSION_MICRO);
 
 	// Select current dir if no root path provided
 	if (string::strcmp(m_preferred_root_path, string::EMPTY) == 0)
@@ -133,7 +133,7 @@ bool Device::init(int argc, char** argv)
 		#ifdef CROWN_BUILD_OPENGL
 		m_renderer = new GLRenderer;
 		#else
-		Log::E("Crown Engine was not built with OpenGL support.");
+		Log::e("Crown Engine was not built with OpenGL support.");
 		return false;
 		#endif
 	}
@@ -142,7 +142,7 @@ bool Device::init(int argc, char** argv)
 		#ifdef CROWN_BUILD_OPENGLES
 		m_renderer = new GLESRenderer;
 		#else
-		Log::E("Crown Engine was not built with OpenGL|ES support.");
+		Log::e("Crown Engine was not built with OpenGL|ES support.");
 		return false;
 		#endif
 	}
@@ -150,16 +150,16 @@ bool Device::init(int argc, char** argv)
 	// Create debug renderer
 	m_debug_renderer = new DebugRenderer(*m_renderer);
 
-	Log::I("Crown Engine initialized.");
+	Log::i("Crown Engine initialized.");
 
-	Log::I("Initializing Game...");
+	Log::i("Initializing Game...");
 
 	const char* game_library_path = m_filesystem->build_os_path(m_filesystem->root_path(), GAME_LIBRARY_NAME);
 	m_game_library = os::open_library(game_library_path);
 
 	if (m_game_library == NULL)
 	{
-		Log::E("Error while loading game library.");
+		Log::e("Error while loading game library.");
 		return false;
 	}
 
@@ -181,7 +181,7 @@ void Device::shutdown()
 {
 	if (is_init() == false)
 	{
-		Log::E("Crown Engine is not initialized.");	
+		Log::e("Crown Engine is not initialized.");	
 		return;
 	}
 
@@ -199,20 +199,20 @@ void Device::shutdown()
 		delete m_input_manager;
 	}
 
-	Log::I("Releasing Renderer...");
+	Log::i("Releasing Renderer...");
 
 	if (m_renderer)
 	{
 		delete m_renderer;
 	}
 
-	Log::I("Releasing DebugRenderer...");
+	Log::i("Releasing DebugRenderer...");
 	if (m_debug_renderer)
 	{
 		delete m_debug_renderer;
 	}
 
-	Log::I("Releasing ResourceManager...");
+	Log::i("Releasing ResourceManager...");
 	if (m_resource_archive)
 	{
 		delete m_resource_archive;
@@ -223,7 +223,7 @@ void Device::shutdown()
 		delete m_resource_manager;
 	}
 
-	Log::I("Releasing Filesystem...");
+	Log::i("Releasing Filesystem...");
 
 	if (m_filesystem)
 	{
@@ -274,7 +274,7 @@ void Device::start()
 {
 	if (is_init() == false)
 	{
-		Log::E("Cannot start uninitialized engine.");
+		Log::e("Cannot start uninitialized engine.");
 		return;
 	}
 
@@ -286,7 +286,7 @@ void Device::stop()
 {
 	if (is_init() == false)
 	{
-		Log::E("Cannot stop uninitialized engine.");
+		Log::e("Cannot stop uninitialized engine.");
 		return;
 	}
 

src/Filesystem.cpp

@@ -39,7 +39,7 @@ Filesystem::Filesystem(const char* root_path)
 
 	string::strncpy(m_root_path, root_path, os::MAX_PATH_LENGTH);
 
-	Log::I("Root path : %s", m_root_path);
+	Log::i("Root path : %s", m_root_path);
 }
 
 //-----------------------------------------------------------------------------

src/Image.cpp

@@ -155,25 +155,25 @@ void Image::ApplyGreyscaleToAlpha(Image* greyscaleImage)
 {
 	if (mPixelFormat != PF_RGBA_8)
 	{
-		Log::E("Image::ApplyGreyscaleToAlpha: Can apply alpha only on RGBA8 pixel formats.");
+		Log::e("Image::ApplyGreyscaleToAlpha: Can apply alpha only on RGBA8 pixel formats.");
 		return;
 	}
 
 	if (greyscaleImage == NULL)
 	{
-		Log::E("Image::ApplyGreyscaleToAlpha: greyscaleImage is NULL.");
+		Log::e("Image::ApplyGreyscaleToAlpha: greyscaleImage is NULL.");
 		return;
 	}
 
 	if (greyscaleImage->mPixelFormat != PF_RGBA_8)
 	{
-		Log::E("Image::ApplyGreyscaleToAlpha: greyscaleImage must have pixel format RGBA8.");
+		Log::e("Image::ApplyGreyscaleToAlpha: greyscaleImage must have pixel format RGBA8.");
 		return;
 	}
 
 	if (mWidth != greyscaleImage->mWidth || mHeight != greyscaleImage->mHeight)
 	{
-		Log::E("Image::ApplyGreyscaleToAlpha: greyscaleImage must have the same dimensions of the image.");
+		Log::e("Image::ApplyGreyscaleToAlpha: greyscaleImage must have the same dimensions of the image.");
 		return;
 	}
 

src/Terrain.cpp

@@ -76,7 +76,7 @@ void Terrain::CreateTerrain(uint32_t xSize, uint32_t zSize, uint32_t tilePerMete
 	mVerticesInSizeX = mTilesInSizeX + 1;
 	mVerticesInSizeZ = mTilesInSizeZ + 1;
 
-	Log::D("Vertices in size x/z: %d %d\n", mVerticesInSizeX, mVerticesInSizeZ);
+	Log::d("Vertices in size x/z: %d %d\n", mVerticesInSizeX, mVerticesInSizeZ);
 
 	uint32_t heightsCount = mVerticesInSizeX * mVerticesInSizeZ;
 

src/Log.cpp → src/core/Log.cpp

@@ -29,22 +29,25 @@ OTHER DEALINGS IN THE SOFTWARE.
 namespace crown
 {
 
-LogLevel Log::mThreshold = LL_DEBUG;
-int32_t Log::mIndentCount = 0;
+LogLevel Log::m_threshold = LL_DEBUG;
+int32_t Log::m_indent_count = 0;
 
-LogLevel Log::GetThreshold()
+//-----------------------------------------------------------------------------
+LogLevel Log::threshold()
 {
-	return mThreshold;
+	return m_threshold;
 }
 
-void Log::SetThreshold(LogLevel threshold)
+//-----------------------------------------------------------------------------
+void Log::set_threshold(LogLevel threshold)
 {
-	mThreshold = threshold;
+	m_threshold = threshold;
 }
 
-void Log::LogMessage(LogLevel level, const char* message, ::va_list arg)
+//-----------------------------------------------------------------------------
+void Log::log_message(LogLevel level, const char* message, ::va_list arg)
 {
-	if (level > mThreshold)
+	if (level > m_threshold)
 	{
 		return;
 	}
@@ -68,48 +71,54 @@ void Log::LogMessage(LogLevel level, const char* message, ::va_list arg)
 	}
 }
 
-void Log::D(const char* message, ...)
+//-----------------------------------------------------------------------------
+void Log::d(const char* message, ...)
 {
 	va_list args;
 	va_start (args, message);
-	LogMessage(LL_DEBUG, message, args);
+	log_message(LL_DEBUG, message, args);
 	va_end (args);
 }
 
-void Log::E(const char* message, ...)
+//-----------------------------------------------------------------------------
+void Log::e(const char* message, ...)
 {
 	va_list args;
 	va_start (args, message);
-	LogMessage(LL_ERROR, message, args);
+	log_message(LL_ERROR, message, args);
 	va_end (args);
 }
 
-void Log::W(const char* message, ...)
+//-----------------------------------------------------------------------------
+void Log::w(const char* message, ...)
 {
 	va_list args;
 	va_start (args, message);
-	LogMessage(LL_WARN, message, args);
+	log_message(LL_WARN, message, args);
 	va_end (args);
 }
 
-void Log::I(const char* message, ...)
+//-----------------------------------------------------------------------------
+void Log::i(const char* message, ...)
 {
 	va_list args;
 	va_start (args, message);
-	LogMessage(LL_INFO, message, args);
+	log_message(LL_INFO, message, args);
 	va_end (args);
 }
 
-void Log::IndentIn()
+//-----------------------------------------------------------------------------
+void Log::indent_in()
 {
-	mIndentCount += 1;
+	m_indent_count += 1;
 }
 
-void Log::IndentOut()
+//-----------------------------------------------------------------------------
+void Log::indent_out()
 {
-	if (mIndentCount >= 1)
+	if (m_indent_count > 0)
 	{
-		mIndentCount -= 1;
+		m_indent_count -= 1;
 	}
 }
 

src/Log.h → src/core/Log.h

@@ -33,9 +33,8 @@ OTHER DEALINGS IN THE SOFTWARE.
 namespace crown
 {
 
-/**
-	Enumerates log levels.
-*/
+
+/// Enumerates log levels.
 enum LogLevel
 {
 	LL_INFO		= 0,
@@ -44,28 +43,32 @@ enum LogLevel
 	LL_DEBUG	= 3
 };
 
+/// Used to log messages.
 class Log
 {
 
 public:
 
-	static LogLevel		GetThreshold();
-	static void			SetThreshold(LogLevel threshold);
+	/// Returns the threshold used to filter out log messages.
+	static LogLevel		threshold();
+
+	/// Sets the thresold used to filter out log messages
+	static void			set_threshold(LogLevel threshold);
 
-	static void			LogMessage(LogLevel level, const char* message, ::va_list arg);
+	static void			log_message(LogLevel level, const char* message, ::va_list arg);
 
-	static void			D(const char* message, ...);
-	static void			E(const char* message, ...);
-	static void			W(const char* message, ...);
-	static void			I(const char* message, ...);
+	static void			d(const char* message, ...);
+	static void			e(const char* message, ...);
+	static void			w(const char* message, ...);
+	static void			i(const char* message, ...);
 
-	static void			IndentIn();
-	static void			IndentOut();
+	static void			indent_in();
+	static void			indent_out();
 
 private:
 
-	static LogLevel		mThreshold;
-	static int32_t		mIndentCount;
+	static LogLevel		m_threshold;
+	static int32_t		m_indent_count;
 };
 
 } // namespace crown

src/core/streams/FileStream.cpp

@@ -94,7 +94,7 @@ uint8_t FileStream::read_byte()
 	
 	if (m_file->read(&buffer, 1, 1) != 1)
 	{
-		Log::E("Could not read from file");
+		Log::e("Could not read from file");
 	}
 
 	return buffer;
@@ -113,7 +113,7 @@ void FileStream::read(void* buffer, size_t size)
 
 	if (m_file->read(buffer, size, 1) != 1)
 	{
-		Log::E("Could not read from file.");
+		Log::e("Could not read from file.");
 	}
 }
 
@@ -195,7 +195,7 @@ void FileStream::write_byte(uint8_t val)
 
 	if (m_file->write(&val, 1, 1) != 1)
 	{
-		Log::E("Could not write to file.");
+		Log::e("Could not write to file.");
 	}
 }
 
@@ -212,7 +212,7 @@ void FileStream::write(const void* buffer, size_t size)
 
 	if (m_file->write(buffer, size, 1) != 1)
 	{
-		Log::E("Could not write to file.");
+		Log::e("Could not write to file.");
 	}
 }
 

src/core/streams/MemoryStream.cpp

@@ -151,7 +151,7 @@ uint8_t MemoryStream::read_byte()
 
 	if (m_memory_offset >= m_memory->size())
 	{
-		Log::E("Trying to read beyond the end of stream.");
+		Log::e("Trying to read beyond the end of stream.");
 	}
 
 	return m_memory->data()[m_memory_offset++];
@@ -166,7 +166,7 @@ void MemoryStream::read(void* buffer, size_t size)
 
 	if (m_memory_offset + size > m_memory->size())
 	{
-		Log::E("Trying to read beyond the end of stream.");
+		Log::e("Trying to read beyond the end of stream.");
 	}
 
 	for (size_t i = 0; i < size; i++)

src/os/linux/EGLRenderWindow.cpp

@@ -50,13 +50,13 @@ EGLRenderWindow::~EGLRenderWindow()
 {
 	if (mEGLDisplay != EGL_NO_DISPLAY)
 	{
-		Log::D("EGLRenderWindow::Destroy: Releasing context...");
+		Log::d("EGLRenderWindow::Destroy: Releasing context...");
 		if (mEGLContext != EGL_NO_CONTEXT)
 		{
 			eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 			eglDestroyContext(mEGLDisplay, mEGLContext);
 		}
-		Log::D("EGLRenderWindow::Destroy: Context released.");
+		Log::d("EGLRenderWindow::Destroy: Context released.");
 
 		if (mEGLWindow != EGL_NO_SURFACE)
 		{
@@ -64,7 +64,7 @@ EGLRenderWindow::~EGLRenderWindow()
 		}
 
 		mEGLWindow = EGL_NO_SURFACE;
-		Log::D("EGLRenderWindow::Destroy: Window Destroyed.");
+		Log::d("EGLRenderWindow::Destroy: Window Destroyed.");
 
 		eglTerminate(mEGLDisplay);
 	}
@@ -77,16 +77,16 @@ EGLRenderWindow::~EGLRenderWindow()
 
 bool EGLRenderWindow::Create(uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t depth, bool /*fullscreen*/)
 {
-	Log::D("EGLRenderWindow::Create: Creating window...");
+	Log::d("EGLRenderWindow::Create: Creating window...");
 	if (!width || !height)
 	{
-		Log::E("Width and height must differ from 0.");
+		Log::e("Width and height must differ from 0.");
 		return false;
 	}
 
 	if (!mEGLDisplay)
 	{
-		Log::E("Unable to open a display");
+		Log::e("Unable to open a display");
 		return false;
 	}
 
@@ -102,7 +102,7 @@ bool EGLRenderWindow::Create(uint32_t x, uint32_t y, uint32_t width, uint32_t he
 
 	if (!mXWindow)
 	{
-		Log::E("Unable to create the X Window.");
+		Log::e("Unable to create the X Window.");
 		return false;
 	}
 
@@ -134,14 +134,14 @@ bool EGLRenderWindow::Create(uint32_t x, uint32_t y, uint32_t width, uint32_t he
 	EGLint     num_config;
 	if (!eglChooseConfig(mEGLDisplay, attribs, &ecfg, 1, &num_config))
 	{
-		Log::E("Unable to choose config.");
+		Log::e("Unable to choose config.");
 		return false;
 	}
 
 	mEGLWindow = eglCreateWindowSurface(mEGLDisplay, ecfg, mXWindow, NULL);
 	if (mEGLWindow == EGL_NO_SURFACE)
 	{
-		Log::E("Unable to create window surface.");
+		Log::e("Unable to create window surface.");
 		return false;
 	}
 
@@ -154,7 +154,7 @@ bool EGLRenderWindow::Create(uint32_t x, uint32_t y, uint32_t width, uint32_t he
 	mEGLContext = eglCreateContext(mEGLDisplay, ecfg, EGL_NO_CONTEXT, ctxattr);
 	if (mEGLContext == EGL_NO_CONTEXT)
 	{
-		Log::E("Unable to create context: " + Str(eglGetError()));
+		Log::e("Unable to create context: " + Str(eglGetError()));
 		return false;
 	}
 
@@ -171,7 +171,7 @@ bool EGLRenderWindow::Create(uint32_t x, uint32_t y, uint32_t width, uint32_t he
 
 	mCreated = true;
 
-	Log::D("EGLRenderWindow::Create: Window created.");
+	Log::d("EGLRenderWindow::Create: Window created.");
 
 	return true;
 }

src/os/linux/File.cpp

@@ -81,7 +81,7 @@ File* File::open(const char* path, FileOpenMode mode)
 
 	if (f->m_file_handle == NULL)
 	{
-		Log::E("File::Open: Could not open file %s", path);
+		Log::e("File::Open: Could not open file %s", path);
 		return NULL;
 	}
 

src/os/linux/GLXRenderWindow.cpp

@@ -53,7 +53,7 @@ bool create_render_window(uint32_t x, uint32_t y, uint32_t width, uint32_t heigh
 
 	if (display == NULL)
 	{
-		Log::E("Unable to open a display");
+		Log::e("Unable to open a display");
 		return false;
 	}
 
@@ -86,7 +86,7 @@ bool create_render_window(uint32_t x, uint32_t y, uint32_t width, uint32_t heigh
 
 	if (!fbConfig)
 	{
-		Log::E("Unable to find a matching FrameBuffer configuration.");
+		Log::e("Unable to find a matching FrameBuffer configuration.");
 		return false;
 	}
 
@@ -94,7 +94,7 @@ bool create_render_window(uint32_t x, uint32_t y, uint32_t width, uint32_t heigh
 
 	if (!visualInfo)
 	{
-		Log::E("Unable to find a matching Visual for the FrameBuffer configuration.");
+		Log::e("Unable to find a matching Visual for the FrameBuffer configuration.");
 		XFree(fbConfig);
 		return false;
 	}
@@ -120,7 +120,7 @@ bool create_render_window(uint32_t x, uint32_t y, uint32_t width, uint32_t heigh
 
 	if (!window)
 	{
-		Log::E("Unable to create the X Window.");
+		Log::e("Unable to create the X Window.");
 		return false;
 	}
 

src/renderers/gl/GLRenderer.cpp

@@ -98,7 +98,7 @@ GLRenderer::GLRenderer() :
 
 	assert(err == GLEW_OK);
 
-	Log::I("GLEW initialized.");
+	Log::i("GLEW initialized.");
 
 	glGetIntegerv(GL_MAX_LIGHTS, &m_max_lights);
 	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &m_max_texture_size);
@@ -119,19 +119,19 @@ GLRenderer::GLRenderer() :
 	const unsigned char* gl_renderer = glGetString(GL_RENDERER);
 	const unsigned char* gl_version = glGetString(GL_VERSION);
 
-	Log::I("OpenGL Vendor\t: %s", gl_vendor);
-	Log::I("OpenGL Renderer\t: %s", gl_renderer);
-	Log::I("OpenGL Version\t: %s", gl_version);
-	Log::I("Min Point Size\t: %f", m_min_max_point_size[0]);
-	Log::I("Max Point Size\t: %f", m_min_max_point_size[1]);
-	Log::I("Min Line Width\t: %f", m_min_max_line_width[0]);
-	Log::I("Max Line Width\t: %f", m_min_max_line_width[1]);
-	Log::I("Max Texture Size\t: %dx%d", m_max_texture_size, m_max_texture_size);
-	Log::I("Max Texture Units\t: %d", m_max_texture_units);
-	Log::I("Max Lights\t\t: %d", m_max_lights);
-	Log::I("Max Vertex Indices\t: %d", m_max_vertex_indices);
-	Log::I("Max Vertex Vertices\t: %d", m_max_vertex_vertices);
-	Log::I("Max Anisotropy\t: %f", m_max_anisotropy);
+	Log::i("OpenGL Vendor\t: %s", gl_vendor);
+	Log::i("OpenGL Renderer\t: %s", gl_renderer);
+	Log::i("OpenGL Version\t: %s", gl_version);
+	Log::i("Min Point Size\t: %f", m_min_max_point_size[0]);
+	Log::i("Max Point Size\t: %f", m_min_max_point_size[1]);
+	Log::i("Min Line Width\t: %f", m_min_max_line_width[0]);
+	Log::i("Max Line Width\t: %f", m_min_max_line_width[1]);
+	Log::i("Max Texture Size\t: %dx%d", m_max_texture_size, m_max_texture_size);
+	Log::i("Max Texture Units\t: %d", m_max_texture_units);
+	Log::i("Max Lights\t\t: %d", m_max_lights);
+	Log::i("Max Vertex Indices\t: %d", m_max_vertex_indices);
+	Log::i("Max Vertex Vertices\t: %d", m_max_vertex_vertices);
+	Log::i("Max Anisotropy\t: %f", m_max_anisotropy);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
@@ -178,7 +178,7 @@ GLRenderer::GLRenderer() :
 	// Disable dithering
 	glDisable(GL_DITHER);
 
-	Log::I("OpenGL Renderer initialized.");
+	Log::i("OpenGL Renderer initialized.");
 }
 
 //-----------------------------------------------------------------------------
@@ -848,25 +848,25 @@ void GLRenderer::check_gl_errors()
 		switch (error)
 		{
 			case GL_INVALID_ENUM:
-				Log::E("GLRenderer: GL_INVALID_ENUM");
+				Log::e("GLRenderer: GL_INVALID_ENUM");
 				break;
 			case GL_INVALID_VALUE:
-				Log::E("GLRenderer: GL_INVALID_VALUE");
+				Log::e("GLRenderer: GL_INVALID_VALUE");
 				break;
 			case GL_INVALID_OPERATION:
-				Log::E("GLRenderer: GL_INVALID_OPERATION");
+				Log::e("GLRenderer: GL_INVALID_OPERATION");
 				break;
 			case GL_STACK_OVERFLOW:
-				Log::E("GLRenderer: GL_STACK_OVERFLOW");
+				Log::e("GLRenderer: GL_STACK_OVERFLOW");
 				break;
 			case GL_STACK_UNDERFLOW:
-				Log::E("GLRenderer: GL_STACK_UNDERFLOW");
+				Log::e("GLRenderer: GL_STACK_UNDERFLOW");
 				break;
 			case GL_OUT_OF_MEMORY:
-				Log::E("GLRenderer: GL_OUT_OF_MEMORY");
+				Log::e("GLRenderer: GL_OUT_OF_MEMORY");
 				break;
 			case GL_TABLE_TOO_LARGE:
-				Log::E("GLRenderer: GL_OUT_OF_MEMORY");
+				Log::e("GLRenderer: GL_OUT_OF_MEMORY");
 				break;
 		}
 	}

src/renderers/gles/GLESRenderer.cpp

@@ -93,19 +93,19 @@ GLESRenderer::GLESRenderer() :
 	const unsigned char* gl_renderer = glGetString(GL_RENDERER);
 	const unsigned char* gl_version = glGetString(GL_VERSION);
 
-	Log::I("OpenGL|ES Vendor\t: %s", gl_vendor);
-	Log::I("OpenGL|ES Renderer\t: %s", gl_renderer);
-	Log::I("OpenGL|ES Version\t: %s", gl_version);
-	Log::I("Min Point Size\t: %f", m_min_max_point_size[0]);
-	Log::I("Max Point Size\t: %f", m_min_max_point_size[1]);
-	Log::I("Min Line Width\t: %f", m_min_max_line_width[0]);
-	Log::I("Max Line Width\t: %f", m_min_max_line_width[1]);
-	Log::I("Max Texture Size\t: %dx%d", m_max_texture_size, m_max_texture_size);
-	Log::I("Max Texture Units\t: %d", m_max_texture_units);
-	Log::I("Max Lights\t\t: %d", m_max_lights);
-	Log::I("Max Vertex Indices\t: %d", m_max_vertex_indices);
-	Log::I("Max Vertex Vertices\t: %d", m_max_vertex_vertices);
-	Log::I("Max Anisotropy\t: %f", m_max_anisotropy);
+	Log::i("OpenGL|ES Vendor\t: %s", gl_vendor);
+	Log::i("OpenGL|ES Renderer\t: %s", gl_renderer);
+	Log::i("OpenGL|ES Version\t: %s", gl_version);
+	Log::i("Min Point Size\t: %f", m_min_max_point_size[0]);
+	Log::i("Max Point Size\t: %f", m_min_max_point_size[1]);
+	Log::i("Min Line Width\t: %f", m_min_max_line_width[0]);
+	Log::i("Max Line Width\t: %f", m_min_max_line_width[1]);
+	Log::i("Max Texture Size\t: %dx%d", m_max_texture_size, m_max_texture_size);
+	Log::i("Max Texture Units\t: %d", m_max_texture_units);
+	Log::i("Max Lights\t\t: %d", m_max_lights);
+	Log::i("Max Vertex Indices\t: %d", m_max_vertex_indices);
+	Log::i("Max Vertex Vertices\t: %d", m_max_vertex_vertices);
+	Log::i("Max Anisotropy\t: %f", m_max_anisotropy);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
@@ -145,7 +145,7 @@ GLESRenderer::GLESRenderer() :
 	// Disable dithering
 	glDisable(GL_DITHER);
 
-	Log::I("OpenGLES Renderer initialized.");
+	Log::i("OpenGLES Renderer initialized.");
 }
 
 //-----------------------------------------------------------------------------
@@ -273,7 +273,7 @@ void GLESRenderer::set_backface_culling(bool culling)
 void GLESRenderer::set_separate_specular_color(bool /* separate */)
 {
 	/* No support for separate specular color, params will be ignored */
-	Log::W("Renderer does not support separate specular color");
+	Log::w("Renderer does not support separate specular color");
 }
 
 void GLESRenderer::set_depth_test(bool test)
@@ -416,7 +416,7 @@ void GLESRenderer::set_shading_type(ShadingType type)
 void GLESRenderer::set_polygon_mode(PolygonMode /* mode */)
 {
 	/* No support for polygon mode, params will be ignored */
-	Log::W("Renderer does not support PolygonMode");
+	Log::w("Renderer does not support PolygonMode");
 }
 
 //-----------------------------------------------------------------------------
@@ -796,22 +796,22 @@ void GLESRenderer::check_gl_errors()
 		switch (error)
 		{
 			case GL_INVALID_ENUM:
-				Log::E("GLESRenderer: GL_INVALID_ENUM");
+				Log::e("GLESRenderer: GL_INVALID_ENUM");
 				break;
 			case GL_INVALID_VALUE:
-				Log::E("GLESRenderer: GL_INVALID_VALUE");
+				Log::e("GLESRenderer: GL_INVALID_VALUE");
 				break;
 			case GL_INVALID_OPERATION:
-				Log::E("GLESRenderer: GL_INVALID_OPERATION");
+				Log::e("GLESRenderer: GL_INVALID_OPERATION");
 				break;
 			case GL_STACK_OVERFLOW:
-				Log::E("GLESRenderer: GL_STACK_OVERFLOW");
+				Log::e("GLESRenderer: GL_STACK_OVERFLOW");
 				break;
 			case GL_STACK_UNDERFLOW:
-				Log::E("GLESRenderer: GL_STACK_UNDERFLOW");
+				Log::e("GLESRenderer: GL_STACK_UNDERFLOW");
 				break;
 			case GL_OUT_OF_MEMORY:
-				Log::E("GLESRenderer: GL_OUT_OF_MEMORY");
+				Log::e("GLESRenderer: GL_OUT_OF_MEMORY");
 				break;
 		}
 	}