2012-02-12 21:45:31 +01:00
|
|
|
/* Copyright (C) 2012 Wildfire Games.
|
2009-04-18 19:00:33 +02:00
|
|
|
* This file is part of 0 A.D.
|
|
|
|
|
*
|
|
|
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
|
|
|
* (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
|
|
|
|
|
2004-06-03 20:38:14 +02:00
|
|
|
#include "precompiled.h"
|
|
|
|
|
|
2004-04-14 23:52:59 +02:00
|
|
|
#include "CLogger.h"
|
2006-12-20 04:09:21 +01:00
|
|
|
#include "CConsole.h"
|
2004-08-15 22:57:04 +02:00
|
|
|
#include "ConfigDB.h"
|
2012-02-12 21:45:31 +01:00
|
|
|
#include "graphics/ShaderManager.h"
|
|
|
|
|
#include "graphics/TextRenderer.h"
|
2010-06-01 00:44:59 +02:00
|
|
|
#include "lib/ogl.h"
|
|
|
|
|
#include "lib/timer.h"
|
2010-03-01 15:55:34 +01:00
|
|
|
#include "lib/utf8.h"
|
2010-06-01 00:44:59 +02:00
|
|
|
#include "lib/res/graphics/unifont.h"
|
2007-04-30 16:35:19 +02:00
|
|
|
#include "lib/sysdep/sysdep.h"
|
2010-06-01 00:44:59 +02:00
|
|
|
#include "ps/Font.h"
|
2011-11-04 02:35:50 +01:00
|
|
|
#include "ps/Profile.h"
|
2012-02-12 21:45:31 +01:00
|
|
|
#include "renderer/Renderer.h"
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2009-11-06 19:35:32 +01:00
|
|
|
#include <ctime>
|
2010-07-07 12:39:41 +02:00
|
|
|
#include <iostream>
|
2005-06-01 22:12:45 +02:00
|
|
|
|
2010-10-13 23:58:31 +02:00
|
|
|
// Disable "'boost::algorithm::detail::is_classifiedF' : assignment operator could not be generated"
|
|
|
|
|
// and "find_format_store.hpp(74) : warning C4100: 'Input' : unreferenced formal parameter"
|
2010-07-05 10:55:09 +02:00
|
|
|
#if MSC_VERSION
|
|
|
|
|
#pragma warning(disable:4512)
|
2010-10-13 23:58:31 +02:00
|
|
|
#pragma warning(disable:4100)
|
2010-07-05 10:55:09 +02:00
|
|
|
#endif
|
|
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
#include <boost/algorithm/string/replace.hpp>
|
|
|
|
|
|
2010-06-06 00:22:21 +02:00
|
|
|
static const double RENDER_TIMEOUT = 10.0; // seconds before messages are deleted
|
2010-06-01 00:44:59 +02:00
|
|
|
static const double RENDER_TIMEOUT_RATE = 10.0; // number of timed-out messages deleted per second
|
|
|
|
|
static const size_t RENDER_LIMIT = 20; // maximum messages on screen at once
|
|
|
|
|
|
2010-09-03 22:06:17 +02:00
|
|
|
static const size_t BUFFER_SIZE = 1024;
|
|
|
|
|
|
2010-06-01 00:44:59 +02:00
|
|
|
extern int g_xres, g_yres;
|
|
|
|
|
|
2006-12-20 04:09:21 +01:00
|
|
|
// Set up a default logger that throws everything away, because that's
|
|
|
|
|
// better than crashing. (This is particularly useful for unit tests which
|
|
|
|
|
// don't care about any log output.)
|
2010-07-05 02:03:10 +02:00
|
|
|
struct BlackHoleStreamBuf : public std::streambuf
|
2006-12-20 04:09:21 +01:00
|
|
|
{
|
|
|
|
|
} blackHoleStreamBuf;
|
2010-07-05 02:03:10 +02:00
|
|
|
std::ostream blackHoleStream(&blackHoleStreamBuf);
|
2008-07-19 21:02:27 +02:00
|
|
|
CLogger nullLogger(&blackHoleStream, &blackHoleStream, false, true);
|
2004-07-11 18:03:26 +02:00
|
|
|
|
2006-12-20 04:09:21 +01:00
|
|
|
CLogger* g_Logger = &nullLogger;
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
const char* html_header0 =
|
|
|
|
|
"<!DOCTYPE html>\n"
|
|
|
|
|
"<meta charset=\"utf-8\">\n"
|
|
|
|
|
"<title>Pyrogenesis Log</title>\n"
|
|
|
|
|
"<style>"
|
|
|
|
|
"body { background: #eee; color: black; font-family: sans-serif; } "
|
|
|
|
|
"p { background: white; margin: 3px 0 3px 0; } "
|
|
|
|
|
".error { color: red; } "
|
|
|
|
|
".warning { color: blue; }"
|
|
|
|
|
"</style>\n"
|
|
|
|
|
"<h2>0 A.D. ";
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
const char* html_header1 = "</h2>\n";
|
2004-04-14 23:52:59 +02:00
|
|
|
|
|
|
|
|
CLogger::CLogger()
|
|
|
|
|
{
|
2011-03-23 14:36:20 +01:00
|
|
|
OsPath mainlogPath(psLogDir()/"mainlog.html");
|
|
|
|
|
m_MainLog = new std::ofstream(OsString(mainlogPath).c_str(), std::ofstream::out | std::ofstream::trunc);
|
2006-09-28 22:41:12 +02:00
|
|
|
|
2011-03-23 14:36:20 +01:00
|
|
|
OsPath interestinglogPath(psLogDir()/"interestinglog.html");
|
|
|
|
|
m_InterestingLog = new std::ofstream(OsString(interestinglogPath).c_str(), std::ofstream::out | std::ofstream::trunc);
|
2006-12-20 04:09:21 +01:00
|
|
|
|
|
|
|
|
m_OwnsStreams = true;
|
2008-07-19 21:02:27 +02:00
|
|
|
m_UseDebugPrintf = true;
|
2006-09-28 22:41:12 +02:00
|
|
|
|
|
|
|
|
Init();
|
|
|
|
|
}
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
CLogger::CLogger(std::ostream* mainLog, std::ostream* interestingLog, bool takeOwnership, bool useDebugPrintf)
|
2006-09-28 22:41:12 +02:00
|
|
|
{
|
|
|
|
|
m_MainLog = mainLog;
|
|
|
|
|
m_InterestingLog = interestingLog;
|
2006-12-20 04:09:21 +01:00
|
|
|
m_OwnsStreams = takeOwnership;
|
2008-07-19 21:02:27 +02:00
|
|
|
m_UseDebugPrintf = useDebugPrintf;
|
2006-09-28 22:41:12 +02:00
|
|
|
|
|
|
|
|
Init();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CLogger::Init()
|
|
|
|
|
{
|
2010-07-06 21:53:08 +02:00
|
|
|
m_RenderLastEraseTime = -1.0;
|
|
|
|
|
// this is called too early to allow us to call timer_Time(),
|
|
|
|
|
// so we'll fill in the initial value later
|
|
|
|
|
|
2006-09-28 22:41:12 +02:00
|
|
|
m_NumberOfMessages = 0;
|
|
|
|
|
m_NumberOfErrors = 0;
|
|
|
|
|
m_NumberOfWarnings = 0;
|
|
|
|
|
|
2004-04-14 23:52:59 +02:00
|
|
|
//Write Headers for the HTML documents
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_MainLog << html_header0 << "Main log" << html_header1;
|
|
|
|
|
|
2004-08-15 22:57:04 +02:00
|
|
|
//Write Headers for the HTML documents
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_InterestingLog << html_header0 << "Main log (warnings and errors only)" << html_header1;
|
2004-04-14 23:52:59 +02:00
|
|
|
}
|
|
|
|
|
|
2010-10-31 23:00:28 +01:00
|
|
|
CLogger::~CLogger()
|
2004-04-14 23:52:59 +02:00
|
|
|
{
|
2010-07-05 02:03:10 +02:00
|
|
|
char buffer[128];
|
|
|
|
|
sprintf_s(buffer, ARRAY_SIZE(buffer), " with %d message(s), %d error(s) and %d warning(s).", m_NumberOfMessages,m_NumberOfErrors,m_NumberOfWarnings);
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2004-08-27 20:47:14 +02:00
|
|
|
time_t t = time(NULL);
|
|
|
|
|
struct tm* now = localtime(&t);
|
2010-07-05 02:03:10 +02:00
|
|
|
char currentDate[17];
|
2011-03-15 21:29:29 +01:00
|
|
|
sprintf_s(currentDate, ARRAY_SIZE(currentDate), "%04d-%02d-%02d", 1900+now->tm_year, 1+now->tm_mon, now->tm_mday);
|
2010-07-05 02:03:10 +02:00
|
|
|
char currentTime[10];
|
|
|
|
|
sprintf_s(currentTime, ARRAY_SIZE(currentTime), "%02d:%02d:%02d", now->tm_hour, now->tm_min, now->tm_sec);
|
2004-08-27 20:47:14 +02:00
|
|
|
|
2004-04-14 23:52:59 +02:00
|
|
|
//Write closing text
|
2004-08-27 20:47:14 +02:00
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_MainLog << "<p>Engine exited successfully on " << currentDate;
|
|
|
|
|
*m_MainLog << " at " << currentTime << buffer << "</p>\n";
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_InterestingLog << "<p>Engine exited successfully on " << currentDate;
|
|
|
|
|
*m_InterestingLog << " at " << currentTime << buffer << "</p>\n";
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2006-12-20 04:09:21 +01:00
|
|
|
if (m_OwnsStreams)
|
|
|
|
|
{
|
2009-11-03 22:46:35 +01:00
|
|
|
SAFE_DELETE(m_InterestingLog);
|
|
|
|
|
SAFE_DELETE(m_MainLog);
|
2006-12-20 04:09:21 +01:00
|
|
|
}
|
2004-04-14 23:52:59 +02:00
|
|
|
}
|
|
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
static std::string ToHTML(const wchar_t* message)
|
|
|
|
|
{
|
2011-05-03 14:38:42 +02:00
|
|
|
Status err;
|
2010-07-05 02:03:10 +02:00
|
|
|
std::string cmessage = utf8_from_wstring(message, &err);
|
|
|
|
|
boost::algorithm::replace_all(cmessage, "&", "&");
|
|
|
|
|
boost::algorithm::replace_all(cmessage, "<", "<");
|
|
|
|
|
return cmessage;
|
|
|
|
|
}
|
|
|
|
|
|
2010-11-21 02:25:16 +01:00
|
|
|
void CLogger::WriteMessage(const wchar_t* message, bool doRender = false)
|
2004-04-14 23:52:59 +02:00
|
|
|
{
|
2010-07-05 02:03:10 +02:00
|
|
|
std::string cmessage = ToHTML(message);
|
|
|
|
|
|
2010-10-31 23:00:28 +01:00
|
|
|
CScopeLock lock(m_Mutex);
|
|
|
|
|
|
2009-04-12 00:53:33 +02:00
|
|
|
++m_NumberOfMessages;
|
2010-06-30 23:41:04 +02:00
|
|
|
// if (m_UseDebugPrintf)
|
|
|
|
|
// debug_printf(L"MESSAGE: %ls\n", message);
|
2004-08-15 22:57:04 +02:00
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_MainLog << "<p>" << cmessage << "</p>\n";
|
2006-09-28 22:41:12 +02:00
|
|
|
m_MainLog->flush();
|
2004-04-14 23:52:59 +02:00
|
|
|
|
2010-11-21 02:25:16 +01:00
|
|
|
if (doRender)
|
|
|
|
|
{
|
|
|
|
|
if (g_Console) g_Console->InsertMessage(L"INFO: %ls", message);
|
|
|
|
|
|
|
|
|
|
PushRenderMessage(Normal, message);
|
|
|
|
|
}
|
2004-04-14 23:52:59 +02:00
|
|
|
}
|
|
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
void CLogger::WriteError(const wchar_t* message)
|
2004-04-14 23:52:59 +02:00
|
|
|
{
|
2010-07-05 02:03:10 +02:00
|
|
|
std::string cmessage = ToHTML(message);
|
|
|
|
|
|
2010-10-31 23:00:28 +01:00
|
|
|
CScopeLock lock(m_Mutex);
|
|
|
|
|
|
2009-04-12 00:53:33 +02:00
|
|
|
++m_NumberOfErrors;
|
2008-07-19 21:02:27 +02:00
|
|
|
if (m_UseDebugPrintf)
|
2009-11-03 22:46:35 +01:00
|
|
|
debug_printf(L"ERROR: %ls\n", message);
|
2009-04-12 00:53:33 +02:00
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
if (g_Console) g_Console->InsertMessage(L"ERROR: %ls", message);
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_InterestingLog << "<p class=\"error\">ERROR: " << cmessage << "</p>\n";
|
2009-04-12 00:53:33 +02:00
|
|
|
m_InterestingLog->flush();
|
|
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_MainLog << "<p class=\"error\">ERROR: " << cmessage << "</p>\n";
|
2006-09-28 22:41:12 +02:00
|
|
|
m_MainLog->flush();
|
2010-06-01 00:44:59 +02:00
|
|
|
|
2010-06-06 00:22:21 +02:00
|
|
|
PushRenderMessage(Error, message);
|
2004-04-14 23:52:59 +02:00
|
|
|
}
|
|
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
void CLogger::WriteWarning(const wchar_t* message)
|
2004-04-14 23:52:59 +02:00
|
|
|
{
|
2010-07-05 02:03:10 +02:00
|
|
|
std::string cmessage = ToHTML(message);
|
|
|
|
|
|
2010-10-31 23:00:28 +01:00
|
|
|
CScopeLock lock(m_Mutex);
|
|
|
|
|
|
2009-04-12 00:53:33 +02:00
|
|
|
++m_NumberOfWarnings;
|
2010-05-09 15:56:06 +02:00
|
|
|
if (m_UseDebugPrintf)
|
|
|
|
|
debug_printf(L"WARNING: %ls\n", message);
|
2009-04-12 00:53:33 +02:00
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
if (g_Console) g_Console->InsertMessage(L"WARNING: %ls", message);
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_InterestingLog << "<p class=\"warning\">WARNING: " << cmessage << "</p>\n";
|
2009-04-12 00:53:33 +02:00
|
|
|
m_InterestingLog->flush();
|
|
|
|
|
|
2010-07-05 02:03:10 +02:00
|
|
|
*m_MainLog << "<p class=\"warning\">WARNING: " << cmessage << "</p>\n";
|
2006-09-28 22:41:12 +02:00
|
|
|
m_MainLog->flush();
|
2010-06-01 00:44:59 +02:00
|
|
|
|
2010-06-06 00:22:21 +02:00
|
|
|
PushRenderMessage(Warning, message);
|
2004-04-14 23:52:59 +02:00
|
|
|
}
|
|
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
void CLogger::LogMessage(const wchar_t* fmt, ...)
|
2004-08-15 22:57:04 +02:00
|
|
|
{
|
2009-04-12 00:53:33 +02:00
|
|
|
va_list argp;
|
2010-09-03 22:06:17 +02:00
|
|
|
wchar_t buffer[BUFFER_SIZE] = {0};
|
2009-04-12 00:53:33 +02:00
|
|
|
|
|
|
|
|
va_start(argp, fmt);
|
2010-01-05 20:55:09 +01:00
|
|
|
if (sys_vswprintf(buffer, ARRAY_SIZE(buffer), fmt, argp) == -1)
|
2009-04-12 00:53:33 +02:00
|
|
|
{
|
|
|
|
|
// Buffer too small - ensure the string is nicely terminated
|
2010-01-01 16:33:07 +01:00
|
|
|
wcscpy_s(buffer+ARRAY_SIZE(buffer)-4, 4, L"...");
|
2009-04-12 00:53:33 +02:00
|
|
|
}
|
|
|
|
|
va_end(argp);
|
2004-08-15 22:57:04 +02:00
|
|
|
|
2009-04-12 00:53:33 +02:00
|
|
|
WriteMessage(buffer);
|
|
|
|
|
}
|
2004-08-15 23:10:49 +02:00
|
|
|
|
2010-11-21 02:25:16 +01:00
|
|
|
void CLogger::LogMessageRender(const wchar_t* fmt, ...)
|
|
|
|
|
{
|
|
|
|
|
va_list argp;
|
|
|
|
|
wchar_t buffer[BUFFER_SIZE] = {0};
|
|
|
|
|
|
|
|
|
|
va_start(argp, fmt);
|
|
|
|
|
if (sys_vswprintf(buffer, ARRAY_SIZE(buffer), fmt, argp) == -1)
|
|
|
|
|
{
|
|
|
|
|
// Buffer too small - ensure the string is nicely terminated
|
|
|
|
|
wcscpy_s(buffer+ARRAY_SIZE(buffer)-4, 4, L"...");
|
|
|
|
|
}
|
|
|
|
|
va_end(argp);
|
|
|
|
|
|
|
|
|
|
WriteMessage(buffer, true);
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
void CLogger::LogWarning(const wchar_t* fmt, ...)
|
2009-04-12 00:53:33 +02:00
|
|
|
{
|
|
|
|
|
va_list argp;
|
2010-09-03 22:06:17 +02:00
|
|
|
wchar_t buffer[BUFFER_SIZE] = {0};
|
2009-04-12 00:53:33 +02:00
|
|
|
|
|
|
|
|
va_start(argp, fmt);
|
2010-01-05 20:55:09 +01:00
|
|
|
if (sys_vswprintf(buffer, ARRAY_SIZE(buffer), fmt, argp) == -1)
|
2009-04-12 00:53:33 +02:00
|
|
|
{
|
|
|
|
|
// Buffer too small - ensure the string is nicely terminated
|
2010-01-01 16:33:07 +01:00
|
|
|
wcscpy_s(buffer+ARRAY_SIZE(buffer)-4, 4, L"...");
|
2009-04-12 00:53:33 +02:00
|
|
|
}
|
|
|
|
|
va_end(argp);
|
2004-08-15 22:57:04 +02:00
|
|
|
|
2009-04-12 00:53:33 +02:00
|
|
|
WriteWarning(buffer);
|
|
|
|
|
}
|
2004-08-15 22:57:04 +02:00
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
void CLogger::LogError(const wchar_t* fmt, ...)
|
2009-04-12 00:53:33 +02:00
|
|
|
{
|
|
|
|
|
va_list argp;
|
2010-09-03 22:06:17 +02:00
|
|
|
wchar_t buffer[BUFFER_SIZE] = {0};
|
2009-04-12 00:53:33 +02:00
|
|
|
|
|
|
|
|
va_start(argp, fmt);
|
2010-01-05 20:55:09 +01:00
|
|
|
if (sys_vswprintf(buffer, ARRAY_SIZE(buffer), fmt, argp) == -1)
|
2009-04-12 00:53:33 +02:00
|
|
|
{
|
|
|
|
|
// Buffer too small - ensure the string is nicely terminated
|
2010-01-01 16:33:07 +01:00
|
|
|
wcscpy_s(buffer+ARRAY_SIZE(buffer)-4, 4, L"...");
|
2009-04-12 00:53:33 +02:00
|
|
|
}
|
|
|
|
|
va_end(argp);
|
2004-08-15 22:57:04 +02:00
|
|
|
|
2009-04-12 00:53:33 +02:00
|
|
|
WriteError(buffer);
|
2004-08-15 22:57:04 +02:00
|
|
|
}
|
2007-03-17 00:32:10 +01:00
|
|
|
|
2010-06-01 00:44:59 +02:00
|
|
|
void CLogger::Render()
|
|
|
|
|
{
|
2011-11-09 14:09:01 +01:00
|
|
|
PROFILE3_GPU("logger");
|
2011-11-04 02:35:50 +01:00
|
|
|
|
2010-06-01 00:44:59 +02:00
|
|
|
CleanupRenderQueue();
|
|
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
CStrW font_name(L"mono-stroke-10");
|
|
|
|
|
CFont font(font_name);
|
2010-06-01 00:44:59 +02:00
|
|
|
int lineSpacing = font.GetLineSpacing();
|
|
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect("gui_text");
|
|
|
|
|
textTech->BeginPass();
|
2010-06-01 00:44:59 +02:00
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
CTextRenderer textRenderer(textTech->GetShader());
|
|
|
|
|
textRenderer.Font(font_name);
|
|
|
|
|
textRenderer.Color(1.0f, 1.0f, 1.0f);
|
2010-06-01 00:44:59 +02:00
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
// Offset by an extra 35px vertically to avoid the top bar.
|
|
|
|
|
textRenderer.Translate(4.0f, 35.0f + lineSpacing, 0.0f);
|
2010-06-01 00:44:59 +02:00
|
|
|
|
2010-10-31 23:00:28 +01:00
|
|
|
// (Lock must come after loading the CFont, since that might log error messages
|
|
|
|
|
// and attempt to lock the mutex recursively which is forbidden)
|
|
|
|
|
CScopeLock lock(m_Mutex);
|
|
|
|
|
|
2010-06-01 00:44:59 +02:00
|
|
|
for (std::deque<RenderedMessage>::iterator it = m_RenderMessages.begin(); it != m_RenderMessages.end(); ++it)
|
|
|
|
|
{
|
|
|
|
|
const wchar_t* type;
|
|
|
|
|
if (it->method == Normal)
|
|
|
|
|
{
|
|
|
|
|
type = L"info";
|
2012-02-12 21:45:31 +01:00
|
|
|
textRenderer.Color(0.0f, 0.8f, 0.0f);
|
2010-06-01 00:44:59 +02:00
|
|
|
}
|
|
|
|
|
else if (it->method == Warning)
|
|
|
|
|
{
|
|
|
|
|
type = L"warning";
|
2012-02-12 21:45:31 +01:00
|
|
|
textRenderer.Color(1.0f, 1.0f, 0.0f);
|
2010-06-01 00:44:59 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
type = L"error";
|
2012-02-12 21:45:31 +01:00
|
|
|
textRenderer.Color(1.0f, 0.0f, 0.0f);
|
2010-06-01 00:44:59 +02:00
|
|
|
}
|
|
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
CMatrix3D savedTransform = textRenderer.GetTransform();
|
|
|
|
|
|
|
|
|
|
textRenderer.Printf(L"[%8.3f] %ls: ", it->time, type);
|
2010-06-01 00:44:59 +02:00
|
|
|
// Display the actual message in white so it's more readable
|
2012-02-12 21:45:31 +01:00
|
|
|
textRenderer.Color(1.0f, 1.0f, 1.0f);
|
|
|
|
|
textRenderer.Printf(L"%ls", it->message.c_str());
|
|
|
|
|
|
|
|
|
|
textRenderer.SetTransform(savedTransform);
|
2010-06-01 00:44:59 +02:00
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
textRenderer.Translate(0.0f, (float)lineSpacing, 0.0f);
|
2010-06-01 00:44:59 +02:00
|
|
|
}
|
|
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
textRenderer.Render();
|
2010-06-01 00:44:59 +02:00
|
|
|
|
2012-02-12 21:45:31 +01:00
|
|
|
textTech->EndPass();
|
2010-06-01 00:44:59 +02:00
|
|
|
}
|
|
|
|
|
|
2010-06-06 00:22:21 +02:00
|
|
|
void CLogger::PushRenderMessage(ELogMethod method, const wchar_t* message)
|
|
|
|
|
{
|
2010-11-03 01:21:52 +01:00
|
|
|
double now = timer_Time();
|
2010-06-06 00:22:21 +02:00
|
|
|
|
|
|
|
|
// Add each message line separately
|
|
|
|
|
const wchar_t* pos = message;
|
|
|
|
|
const wchar_t* eol;
|
|
|
|
|
while ((eol = wcschr(pos, L'\n')) != NULL)
|
|
|
|
|
{
|
|
|
|
|
if (eol != pos)
|
|
|
|
|
{
|
|
|
|
|
RenderedMessage r = { method, now, std::wstring(pos, eol) };
|
|
|
|
|
m_RenderMessages.push_back(r);
|
|
|
|
|
}
|
|
|
|
|
pos = eol + 1;
|
|
|
|
|
}
|
|
|
|
|
// Add the last line, if we didn't end on a \n
|
|
|
|
|
if (*pos != L'\0')
|
|
|
|
|
{
|
|
|
|
|
RenderedMessage r = { method, now, std::wstring(pos) };
|
|
|
|
|
m_RenderMessages.push_back(r);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-01 00:44:59 +02:00
|
|
|
void CLogger::CleanupRenderQueue()
|
|
|
|
|
{
|
2010-10-31 23:00:28 +01:00
|
|
|
CScopeLock lock(m_Mutex);
|
|
|
|
|
|
2010-06-01 00:44:59 +02:00
|
|
|
if (m_RenderMessages.empty())
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
double now = timer_Time();
|
|
|
|
|
|
|
|
|
|
// Initialise the timer on the first call (since we can't do it in the ctor)
|
|
|
|
|
if (m_RenderLastEraseTime == -1.0)
|
|
|
|
|
m_RenderLastEraseTime = now;
|
|
|
|
|
|
|
|
|
|
// Delete old messages, approximately at the given rate limit (and at most one per frame)
|
|
|
|
|
if (now - m_RenderLastEraseTime > 1.0/RENDER_TIMEOUT_RATE)
|
|
|
|
|
{
|
|
|
|
|
if (m_RenderMessages[0].time + RENDER_TIMEOUT < now)
|
|
|
|
|
{
|
|
|
|
|
m_RenderMessages.pop_front();
|
|
|
|
|
m_RenderLastEraseTime = now;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If there's still too many then delete the oldest
|
|
|
|
|
if (m_RenderMessages.size() > RENDER_LIMIT)
|
|
|
|
|
m_RenderMessages.erase(m_RenderMessages.begin(), m_RenderMessages.end() - RENDER_LIMIT);
|
|
|
|
|
}
|
2009-11-03 22:46:35 +01:00
|
|
|
|
2007-03-17 00:32:10 +01:00
|
|
|
TestLogger::TestLogger()
|
|
|
|
|
{
|
|
|
|
|
m_OldLogger = g_Logger;
|
2008-07-19 21:02:27 +02:00
|
|
|
g_Logger = new CLogger(&m_Stream, &blackHoleStream, false, false);
|
2007-03-17 00:32:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TestLogger::~TestLogger()
|
|
|
|
|
{
|
|
|
|
|
delete g_Logger;
|
|
|
|
|
g_Logger = m_OldLogger;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-03 22:46:35 +01:00
|
|
|
std::wstring TestLogger::GetOutput()
|
2007-03-17 00:32:10 +01:00
|
|
|
{
|
2011-05-03 14:38:42 +02:00
|
|
|
Status err;
|
2010-07-05 02:03:10 +02:00
|
|
|
return wstring_from_utf8(m_Stream.str(), &err);
|
2007-03-17 00:32:10 +01:00
|
|
|
}
|
2010-06-30 23:41:04 +02:00
|
|
|
|
|
|
|
|
TestStdoutLogger::TestStdoutLogger()
|
|
|
|
|
{
|
|
|
|
|
m_OldLogger = g_Logger;
|
2010-07-05 02:03:10 +02:00
|
|
|
g_Logger = new CLogger(&std::cout, &blackHoleStream, false, false);
|
2010-06-30 23:41:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TestStdoutLogger::~TestStdoutLogger()
|
|
|
|
|
{
|
|
|
|
|
delete g_Logger;
|
|
|
|
|
g_Logger = m_OldLogger;
|
|
|
|
|
}
|
