/*
* The ManaPlus Client
* Copyright (C) 2011-2017 The ManaPlus Developers
*
* This file is part of The ManaPlus Client.
*
* This program 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
* any later version.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "test/testmain.h"
#ifdef USE_OPENGL
#include "logger.h"
#include "settings.h"
#include "fs/paths.h"
#include "utils/delete2.h"
#include "utils/process.h"
#include "debug.h"
std::string fileName;
extern char *selfName;
TestMain::TestMain() :
log(new Logger),
mConfig()
{
fileName = getSelfName();
log->setLogFile(settings.localDataDir + std::string("/manaplustest.log"));
}
TestMain::~TestMain()
{
delete2(log);
}
void TestMain::initConfig()
{
mConfig.init(settings.configDir + "/test.xml");
mConfig.clear();
// mConfig.setDefaultValues(getConfigDefaults());
mConfig.setValue("hwaccel", false);
mConfig.setValue("screen", false);
mConfig.setValue("sound", false);
mConfig.setValue("guialpha", 0.8F);
// mConfig.setValue("remember", true);
mConfig.setValue("sfxVolume", 50);
mConfig.setValue("musicVolume", 60);
mConfig.setValue("fpslimit", 0);
mConfig.setValue("customcursor", true);
mConfig.setValue("useScreenshotDirectorySuffix", true);
mConfig.setValue("ChatLogLength", 128);
mConfig.setValue("screenwidth", 800);
mConfig.setValue("screenheight", 600);
}
int TestMain::exec(const bool testAudio)
{
initConfig();
int softwareTest = invokeSoftwareRenderTest("1");
int soundTest = -1;
int rescaleTest[6];
int softFps = 0;
int normalOpenGLFps = 0;
int safeOpenGLFps = 0;
int modernOpenGLFps = 0;
int textureSize[6];
std::string textureSizeStr;
RenderType openGLMode = RENDER_SOFTWARE;
int detectMode = 0;
for (int f = 0; f < 6; f ++)
{
rescaleTest[f] = -1;
textureSize[f] = 1024;
}
std::string info;
const int videoDetectTest = invokeTest("99");
if (!videoDetectTest)
detectMode = readValue2(99);
int normalOpenGLTest = invokeNormalOpenGLRenderTest("2");
int safeOpenGLTest = invokeSafeOpenGLRenderTest("3");
int modernOpenGLTest = invokeModernOpenGLRenderTest("19");
if (testAudio)
soundTest = invokeTest4();
else
soundTest = 1;
info.append(strprintf("%d.%d,%d,%d,%d.", soundTest, softwareTest,
normalOpenGLTest, safeOpenGLTest, modernOpenGLTest));
if (!softwareTest)
{
int softFpsTest = invokeSoftwareRenderTest("8");
info.append(strprintf("%d", softFpsTest));
if (!softFpsTest)
{
softFps = readValue2(8);
info.append(strprintf(",%d", softFps));
if (!softFps)
{
softwareTest = -1;
softFpsTest = -1;
}
else
{
rescaleTest[0] = invokeSoftwareRenderTest("5");
info.append(strprintf(",%d", rescaleTest[0]));
}
}
else
{
softwareTest = -1;
}
}
info.append(".");
if (!modernOpenGLTest)
{
int modernOpenGLFpsTest = invokeModernOpenGLRenderTest("17");
info.append(strprintf("%d", modernOpenGLFpsTest));
if (!modernOpenGLFpsTest)
{
modernOpenGLFps = readValue2(17);
info.append(strprintf(",%d", modernOpenGLFps));
if (!modernOpenGLFps)
{
modernOpenGLTest = -1;
modernOpenGLFpsTest = -1;
}
else
{
rescaleTest[3] = invokeModernOpenGLRenderTest("18");
info.append(strprintf(",%d", rescaleTest[3]));
}
}
else
{
modernOpenGLTest = -1;
}
}
info.append(".");
if (!normalOpenGLTest)
{
int normalOpenGLFpsTest = invokeNormalOpenGLRenderTest("9");
info.append(strprintf("%d", normalOpenGLFpsTest));
if (!normalOpenGLFpsTest)
{
normalOpenGLFps = readValue2(9);
info.append(strprintf(",%d", normalOpenGLFps));
if (!normalOpenGLFps)
{
normalOpenGLTest = -1;
normalOpenGLFpsTest = -1;
}
else
{
rescaleTest[1] = invokeNormalOpenGLRenderTest("6");
info.append(strprintf(",%d", rescaleTest[1]));
}
}
else
{
normalOpenGLTest = -1;
}
}
info.append(".");
if (!safeOpenGLTest)
{
int safeOpenGLFpsTest = invokeSafeOpenGLRenderTest("10");
info.append(strprintf("%d", safeOpenGLFpsTest));
if (!safeOpenGLFpsTest)
{
safeOpenGLFps = readValue2(10);
info.append(strprintf(",%d", safeOpenGLFps));
if (!safeOpenGLFps)
{
safeOpenGLTest = -1;
safeOpenGLFpsTest = -1;
}
else
{
rescaleTest[2] = invokeSafeOpenGLRenderTest("7");
info.append(strprintf(",%d", rescaleTest[2]));
}
}
else
{
safeOpenGLTest = -1;
}
}
info.append(".");
int maxFps = softFps;
if (maxFps < normalOpenGLFps)
{
openGLMode = RENDER_NORMAL_OPENGL;
maxFps = normalOpenGLFps;
}
if (maxFps < modernOpenGLFps)
{
openGLMode = RENDER_MODERN_OPENGL;
maxFps = modernOpenGLFps;
}
if (maxFps < safeOpenGLFps)
{
openGLMode = RENDER_SAFE_OPENGL;
maxFps = safeOpenGLFps;
}
int batchSize = 256;
if (!invokeNormalOpenBatchTest("11"))
batchSize = readValue2(11);
if (batchSize < 256)
batchSize = 256;
if (!invokeNormalOpenBatchTest("14"))
{
textureSize[CAST_SIZE(RENDER_NORMAL_OPENGL)]
= readValue2(14);
}
if (!invokeModernOpenBatchTest("15"))
{
textureSize[CAST_SIZE(RENDER_MODERN_OPENGL)]
= readValue2(15);
}
if (!invokeSafeOpenBatchTest("16"))
{
textureSize[CAST_SIZE(RENDER_SAFE_OPENGL)]
= readValue2(16);
}
if (!invokeMobileOpenBatchTest("20"))
{
textureSize[CAST_SIZE(RENDER_GLES_OPENGL)]
= readValue2(20);
}
for (int f = 0; f < 6; f ++)
info.append(strprintf(",%d", textureSize[f]));
info.append(",-");
textureSizeStr = toString(textureSize[0]);
for (int f = 1; f < 6; f ++)
textureSizeStr.append(strprintf(",%d", textureSize[f]));
// if OpenGL implimentation is not good, disable it.
if (!(detectMode & 15))
openGLMode = RENDER_SOFTWARE;
writeConfig(openGLMode, rescaleTest[CAST_SIZE(openGLMode)],
soundTest, info, batchSize, textureSizeStr, detectMode);
return 0;
}
void TestMain::writeConfig(const RenderType openGLMode,
const int rescale,
const int sound,
const std::string &info,
const int batchSize A_UNUSED,
const std::string &textureSize,
const int detectMode)
{
mConfig.init(settings.configDir + "/config.xml");
log->log("set mode to %d", CAST_S32(openGLMode));
// searched values
mConfig.setValue("opengl", CAST_S32(openGLMode));
mConfig.setValue("showBackground", !rescale);
mConfig.setValue("sound", !sound);
// better performance
mConfig.setValue("hwaccel", true);
mConfig.setValue("fpslimit", 60);
mConfig.setValue("altfpslimit", 2);
mConfig.setValue("safemode", false);
mConfig.setValue("enableMapReduce", true);
mConfig.setValue("textureSize", textureSize);
// max batch size
// mConfig.setValue("batchsize", batchSize);
// additional modes
mConfig.setValue("useTextureSampler",
static_cast<bool>(detectMode & 1024));
mConfig.setValue("compresstextures",
static_cast<bool>(detectMode & 2048));
// stats
mConfig.setValue("testInfo", info);
mConfig.write();
}
int TestMain::readValue2(const int ver)
{
const int def = readValue(ver, 0);
log->log("value for %d = %d", ver, def);
return def;
}
int TestMain::readValue(const int ver, int def)
{
std::string tmp;
int var;
std::ifstream file;
file.open((settings.localDataDir + std::string("/test.log")).c_str(),
std::ios::in);
if (!getline(file, tmp))
{
file.close();
return def;
}
var = atoi(tmp.c_str());
if (ver != var || !getline(file, tmp))
{
file.close();
return def;
}
def = atoi(tmp.c_str());
file.close();
return def;
}
int TestMain::invokeTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_SOFTWARE));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test);
return ret;
}
int TestMain::invokeTest4()
{
mConfig.setValue("sound", true);
const int ret = invokeTest("4");
log->log("4: %d", ret);
return ret;
}
int TestMain::invokeSoftwareRenderTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_SOFTWARE));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
log->log("%s: %d", test.c_str(), ret);
return ret;
}
int TestMain::invokeNormalOpenGLRenderTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_NORMAL_OPENGL));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
log->log("%s: %d", test.c_str(), ret);
return ret;
}
int TestMain::invokeModernOpenGLRenderTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_MODERN_OPENGL));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
log->log("%s: %d", test.c_str(), ret);
return ret;
}
int TestMain::invokeNormalOpenBatchTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_NORMAL_OPENGL));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
// log->log("%s: %d", test.c_str(), ret);
return ret;
}
int TestMain::invokeModernOpenBatchTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_MODERN_OPENGL));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
// log->log("%s: %d", test.c_str(), ret);
return ret;
}
int TestMain::invokeMobileOpenBatchTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_GLES_OPENGL));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
// log->log("%s: %d", test.c_str(), ret);
return ret;
}
int TestMain::invokeSafeOpenBatchTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_SAFE_OPENGL));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
// log->log("%s: %d", test.c_str(), ret);
return ret;
}
int TestMain::invokeSafeOpenGLRenderTest(const std::string &test)
{
mConfig.setValue("opengl", CAST_S32(RENDER_SAFE_OPENGL));
mConfig.write();
const int ret = execFileWait(fileName, fileName, "-t", test, 30);
log->log("%s: %d", test.c_str(), ret);
return ret;
}
#endif // USE_OPENGL