testlauncher.cpp

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2011-2019 The ManaPlus Developers
 * Copyright (C) 2019-2021 Andrei Karas
 *
 * 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/testlauncher.h"
 
#ifdef USE_OPENGL
 
#include "graphicsmanager.h"
#include "settings.h"
#include "soundmanager.h"
 
#include "fs/virtfs/rwops.h"
 
#include "gui/skin.h"
#include "gui/theme.h"
 
#include "gui/fonts/font.h"
 
#include "utils/pnglib.h"
#include "utils/stringutils.h"
 
#include "render/graphics.h"
 
#include "render/vertexes/imagecollection.h"
 
#include "resources/openglimagehelper.h"
#include "resources/screenshothelper.h"
#include "resources/surfaceimagehelper.h"
#include "resources/wallpaper.h"
 
#include "resources/dye/dye.h"
#if defined __linux__ || defined __linux
#ifdef SIMD_SUPPORTED
#include "resources/dye/dyepalette.h"
#endif // SIMD_SUPPORTED
#endif // defined __linux__ || defined __linux
 
#include "resources/image/image.h"
 
PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#ifndef USE_SDL2
#include <SDL_gfxBlitFunc.h>
#endif // USE_SDL2
PRAGMA48(GCC diagnostic pop)
 
#include <unistd.h>
 
#ifdef WIN32
#include <windows.h>
#define sleep(seconds) Sleep((seconds) * 1000)
#endif // WIN32
 
#include <sys/time.h>
 
#include "localconsts.h"
 
#ifndef SDL_BIG_ENDIAN
#error missing SDL_endian.h
#endif // SDL_BYTEORDER
 
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
#ifndef USE_SDL2
#include "resources/sdlgfxblitfunc.h"
#endif // USE_SDL2
#endif // SDL_BYTEORDER == SDL_LIL_ENDIAN
 
#include "debug.h"
 
extern Font *boldFont;
 
TestLauncher::TestLauncher(std::string test) :
 mTest(test),
 file()
{
 file.open(pathJoin(settings.localDataDir, "test.log").c_str(),
 std::ios::out);
}
 
TestLauncher::~TestLauncher()
{
 file.close();
}
 
int TestLauncher::exec()
{
 if (mTest == "1" || mTest == "2" || mTest == "3" || mTest == "19")
 return testBackend();
 else if (mTest == "4")
 return testSound();
 else if (mTest == "5" || mTest == "6" || mTest == "7" || mTest == "18")
 return testRescale();
 else if (mTest == "8" || mTest == "9" || mTest == "10" || mTest == "17")
 return testFps();
 else if (mTest == "11")
 return testBatches();
 else if (mTest == "14" || mTest == "15" || mTest == "16" || mTest == "20")
 return testTextures();
 else if (mTest == "99")
 return testVideoDetection();
 else if (mTest == "100")
 return testInternal();
 else if (mTest == "101")
 return testDye();
 else if (mTest == "102")
 return testDraw();
 else if (mTest == "103")
 return testFps2();
 else if (mTest == "104")
 return testFps3();
 else if (mTest == "105")
 return testDyeSSpeed();
 else if (mTest == "106")
 return testStackSpeed();
 else if (mTest == "107")
 return testDyeASpeed();
 else if (mTest == "108")
 return testBlitSpeed();
 
 return -1;
}
 
int TestLauncher::testBackend() const
{
 const Image *const img = Theme::getImageFromTheme(
 "graphics/sprites/arrow_up.png");
 if (img == nullptr)
 return 1;
 const int cnt = 100;
 
 for (int f = 0; f < cnt; f ++)
 {
 mainGraphics->drawImage(img, cnt * 7, cnt * 5);
 mainGraphics->updateScreen();
 }
 
 sleep(1);
 return 0;
}
 
int TestLauncher::testSound() const
{
 soundManager.playGuiSfx("system/newmessage.ogg");
 sleep(1);
 soundManager.playSfx("system/newmessage.ogg", 0, 0);
 soundManager.playMusic("sfx/system/newmessage.ogg", SkipError_false);
 sleep(3);
 soundManager.stopMusic();
 return 0;
}
 
int TestLauncher::testRescale() const
{
 Wallpaper::loadWallpapers();
 const std::string wallpaperName = Wallpaper::getWallpaper(800, 600);
 const volatile Image *const img = Theme::getImageFromTheme(wallpaperName);
 if (img == nullptr)
 return 1;
 
 sleep(1);
 return 0;
}
 
PRAGMA45(GCC diagnostic push)
PRAGMA45(GCC diagnostic ignored "-Wunused-result")
 
int TestLauncher::testFps()
{
 timeval start;
 timeval end;
 
 Wallpaper::loadWallpapers();
 Wallpaper::getWallpaper(800, 600);
 Image *img[5];
 const int sz = 4;
 
 img[0] = Theme::getImageFromTheme("graphics/sprites/arrow_up.png");
 img[1] = Theme::getImageFromTheme(
 "graphics/gui/target-cursor-normal-l.png");
 img[2] = Theme::getImageFromTheme("themes/wood/window.png");
 img[3] = Theme::getImageFromTheme("themes/pink/window.png");
 img[4] = Theme::getImageFromTheme("graphics/images/login_wallpaper.png");
 int idx = 0;
 
 const int cnt = 50;
 
 gettimeofday(&start, nullptr);
 for (int k = 0; k < cnt; k ++)
 {
 for (int x = 0; x < 800; x += 30)
 {
 for (int y = 0; y < 600; y += 50)
 {
 mainGraphics->drawImage(img[idx], x, y);
 idx ++;
 if (idx > sz)
 idx = 0;
 mainGraphics->drawImage(img[idx], x, y);
 idx ++;
 if (idx > sz)
 idx = 0;
 }
 }
 mainGraphics->updateScreen();
 }
 
 gettimeofday(&end, nullptr);
 const int tFps = calcFps(start, end, cnt);
 file << mTest << std::endl;
 file << tFps << std::endl;
 
 printf("fps: %d\n", tFps / 10);
 sleep(1);
 return 0;
}
 
int TestLauncher::testFps2()
{
 timeval start;
 timeval end;
 
 Wallpaper::loadWallpapers();
 Wallpaper::getWallpaper(800, 600);
 Image *img[1];
 
 img[0] = Theme::getImageFromTheme("graphics/images/login_wallpaper.png");
 mainGraphics->drawImage(img[0], 0, 0);
 
 const int cnt = 500;
 
 gettimeofday(&start, nullptr);
 for (int k = 0; k < cnt; k ++)
 {
 for (int f = 0; f < 300; f ++)
 mainGraphics->testDraw();
 mainGraphics->updateScreen();
 }
 
 gettimeofday(&end, nullptr);
 const int tFps = calcFps(start, end, cnt);
 file << mTest << std::endl;
 file << tFps << std::endl;
 
 printf("fps: %d\n", tFps / 10);
 sleep(1);
 return 0;
}
 
int TestLauncher::testFps3()
{
 timeval start;
 timeval end;
 
 Wallpaper::loadWallpapers();
 Wallpaper::getWallpaper(800, 600);
 Image *img[2];
 
 img[0] = Theme::getImageFromTheme("graphics/sprites/arrow_up.png");
 img[1] = Theme::getImageFromTheme("graphics/sprites/arrow_left.png");
 ImageVertexes *const vert1 = new ImageVertexes;
 vert1->image = img[0];
 ImageVertexes *const vert2 = new ImageVertexes;
 vert2->image = img[1];
 
 for (int f = 0; f < 50; f ++)
 {
 for (int d = 0; d < 50; d ++)
 {
 mainGraphics->calcTileVertexes(vert1, img[0], f * 16, d * 12);
 mainGraphics->calcTileVertexes(vert1, img[1], f * 16 + 5, d * 12);
 }
 }
 mainGraphics->finalize(vert1);
 mainGraphics->finalize(vert2);
 
 const int cnt = 2000;
 
 gettimeofday(&start, nullptr);
 for (int k = 0; k < cnt; k ++)
 {
 mainGraphics->drawTileVertexes(vert1);
 mainGraphics->drawTileVertexes(vert2);
 mainGraphics->updateScreen();
 }
 
 gettimeofday(&end, nullptr);
 const int tFps = calcFps(start, end, cnt);
 file << mTest << std::endl;
 file << tFps << std::endl;
 
 printf("fps: %d\n", tFps / 10);
 sleep(1);
 return 0;
}
PRAGMA45(GCC diagnostic pop)
 
int TestLauncher::testBatches()
{
 int batches = 512;
 
 file << mTest << std::endl;
 file << batches << std::endl;
 return 0;
}
 
int TestLauncher::testTextures()
{
 int maxSize = 512;
 int nextSize = 512;
 int sz = OpenGLImageHelper::getTextureSize() + 1;
 if (sz > 16500)
 sz = 16500;
 
 const uint32_t bytes1[] =
 {
 0xFFFF0000U, 0xFFFFFF00U, 0xFF00FFFFU, 0xFF0000FFU,
 0xFF000000U, 0xFFFF00FFU
 };
 
 const uint32_t bytes2[] =
 {
 0xFF0000FFU, 0xFF00FFFFU, 0xFFFFFF00U, 0xFFFF0000U,
 0xFF000000U, 0xFFFF00FFU
 };
 
 for (nextSize = 512; nextSize < sz; nextSize *= 2)
 {
 mainGraphics->clearScreen();
 SDL_Surface *const surface = imageHelper->create32BitSurface(
 nextSize, nextSize);
 if (surface == nullptr)
 break;
 uint32_t *pixels = static_cast<uint32_t*>(surface->pixels);
 for (int f = 0; f < 6; f ++)
 pixels[f] = bytes1[f];
 graphicsManager.getLastError();
 graphicsManager.resetCachedError();
 Image *const image = imageHelper->loadSurface(surface);
 SDL_FreeSurface(surface);
 if (image == nullptr)
 break;
 
 if (graphicsManager.getLastErrorCached() != GL_NO_ERROR)
 {
 delete image;
 break;
 }
 Image *const subImage = image->getSubImage(0, 0, 10, 10);
 if (subImage == nullptr)
 {
 delete image;
 break;
 }
 mainGraphics->drawImage(subImage, 0, 0);
 mainGraphics->updateScreen();
 mainGraphics->drawImage(subImage, 0, 0);
 delete subImage;
 SDL_Surface *const screen1 = screenshortHelper->getScreenshot();
 SDL_Surface *const screen2 = ImageHelper::convertTo32Bit(screen1);
 SDL_FreeSurface(screen1);
 if (screen2 == nullptr)
 break;
 pixels = static_cast<uint32_t*>(screen2->pixels);
 bool fail(false);
 for (int f = 0; f < 6; f ++)
 {
 if (pixels[f] != bytes2[f])
 {
 fail = true;
 break;
 }
 }
 
 SDL_FreeSurface(screen2);
 if (fail)
 break;
 
 maxSize = nextSize;
 }
 
 file << mTest << std::endl;
 file << maxSize << std::endl;
 printf("OpenGL max size: %d\n", sz);
 printf("actual max size: %d\n", maxSize);
 return 0;
}
 
PRAGMA45(GCC diagnostic push)
PRAGMA45(GCC diagnostic ignored "-Wunused-result")
 
int TestLauncher::testInternal()
{
 timeval start;
 timeval end;
 
 Wallpaper::loadWallpapers();
 Wallpaper::getWallpaper(800, 600);
 Image *img[4];
 
 img[0] = Theme::getImageFromTheme(
 "graphics/sprites/manaplus_emotions.png");
 img[1] = Theme::getImageFromTheme(
 "graphics/sprites/manaplus_emotions.png");
 img[2] = Theme::getImageFromTheme("graphics/sprites/arrow_left.png");
 img[3] = Theme::getImageFromTheme("graphics/sprites/arrow_right.png");
 int idx = 0;
 const int mem = mainGraphics->getMemoryUsage();
 
// int cnt = 5;
 const int cnt = 5000;
 
 gettimeofday(&start, nullptr);
 for (int k = 0; k < cnt; k ++)
 {
 for (int x = 0; x < 800; x += 20)
 {
 for (int y = 0; y < 600; y += 25)
 {
 mainGraphics->drawImage(img[idx], x, y);
 mainGraphics->drawImage(img[idx], x + 1, y);
 mainGraphics->drawImage(img[idx], x, y + 5);
 
 idx ++;
 if (idx > 3)
 idx = 0;
 }
 }
 mainGraphics->updateScreen();
 }
 
 gettimeofday(&end, nullptr);
 const int tFps = calcFps(start, end, cnt);
 file << mTest << std::endl;
 file << tFps << std::endl;
 file << mem << std::endl;
 
 sleep(1);
 return 0;
}
 
PRAGMA45(GCC diagnostic pop)
 
int TestLauncher::testDye()
{
 SDL_RWops *rw = VirtFs::rwopsOpenRead(
 "graphics/sprites/arrow_up.png");
 Dye *d = nullptr;
 
 if (rw != nullptr)
 {
 Image *image = d != nullptr ? surfaceImageHelper->load(rw, *d)
 : surfaceImageHelper->load(rw);
 if (image != nullptr)
 {
 const SDL_Rect &rect = image->mBounds;
 SDL_Surface *surface = surfaceImageHelper->create32BitSurface(
 rect.w, rect.h);
 if (surface != nullptr)
 {
 SurfaceImageHelper::combineSurface(image->mSDLSurface, nullptr,
 surface, nullptr);
 PngLib::writePNG(image->mSDLSurface,
 settings.tempDir + "/testimage1.png");
 PngLib::writePNG(surface,
 settings.tempDir + "/testimage2.png");
 }
 
 rw = VirtFs::rwopsOpenRead(
 "graphics/sprites/arrow_up.png");
 d = new Dye("S:#0000ff,00ff00,5c5cff,ff0000");
 image = surfaceImageHelper->load(rw, *d);
 if (image != nullptr)
 {
 surface = surfaceImageHelper->create32BitSurface(
 rect.w, rect.h);
 if (surface != nullptr)
 {
 SurfaceImageHelper::combineSurface(image->mSDLSurface,
 nullptr, surface, nullptr);
 PngLib::writePNG(image->mSDLSurface,
 settings.tempDir + "/testimage3.png");
 PngLib::writePNG(surface,
 settings.tempDir + "/testimage4.png");
 }
 }
 }
 }
 return 0;
}
 
#if defined __linux__ || defined __linux
#if defined(SIMD_SUPPORTED) || (SDL_BYTEORDER == SDL_LIL_ENDIAN \
&& !defined(USE_SDL2))
static void calcTime(const char *const msg1,
 const char *const msg2,
 const timespec &time1,
 timespec &time2,
 const uint32_t *const buf)
{
 clock_gettime(CLOCK_MONOTONIC, &time2);
 long diff = ((static_cast<long int>(time2.tv_sec) * 1000000000L
 + static_cast<long int>(time2.tv_nsec)) / 1) -
 ((static_cast<long int>(time1.tv_sec) * 1000000000L
 + static_cast<long int>(time1.tv_nsec)) / 1);
 printf("%s: %u\n", msg1, buf[0]);
 printf("%s: %011ld\n", msg2, diff);
}
#endif // defined(SIMD_SUPPORTED) || (SDL_BYTEORDER == SDL_LIL_ENDIAN
 
#ifdef SIMD_SUPPORTED
static void initBuffer(uint32_t *const buf,
 const int sz)
{
 for (int f = 0; f < sz; f ++)
 buf[f] = f;
}
 
#define runDyeTest(msg1, msg2, func) \
 initBuffer(buf, sz); \
 pal.func(buf, sz); \
 clock_gettime(CLOCK_MONOTONIC, &time1); \
 for (int f = 0; f < 50000; f ++) \
 pal.func(buf, sz); \
 calcTime(msg1, \
 msg2, \
 time1, \
 time2, \
 buf)
#endif // SIMD_SUPPORTED
#endif // defined __linux__ || defined __linux
 
int TestLauncher::testDyeSSpeed()
{
#if defined __linux__ || defined __linux
#ifdef SIMD_SUPPORTED
 const int sz = 100000;
 uint32_t buf[sz];
 timespec time1;
 timespec time2;
 
 DyePalette pal("#0000ff,000000,000020,706050", 6);
 
 runDyeTest("dye s salt", "default time", replaceSColorDefault);
 runDyeTest("dye s salt", "sse2 time ", replaceSColorSse2);
 runDyeTest("dye s salt", "avx2 time ", replaceSColorAvx2);
#endif // SIMD_SUPPORTED
#endif // defined __linux__ || defined __linux
 return 0;
}
 
int TestLauncher::testDyeASpeed()
{
#if defined __linux__ || defined __linux
#ifdef SIMD_SUPPORTED
 const int sz = 100000;
 uint32_t buf[sz];
 timespec time1;
 timespec time2;
 
 DyePalette pal("#0000ffff,00000000,000020ff,70605040", 8);
 
 runDyeTest("dye a salt", "default time", replaceAColorDefault);
 runDyeTest("dye a salt", "sse2 time ", replaceAColorSse2);
 runDyeTest("dye a salt", "avx2 time ", replaceAColorAvx2);
#endif // SIMD_SUPPORTED
#endif // defined __linux__ || defined __linux
 return 0;
}
 
int TestLauncher::testBlitSpeed()
{
#if defined __linux__ || defined __linux
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
#ifndef USE_SDL2
 
 timespec time1;
 timespec time2;
 const int cnt1 = 10000;
 const int cnt2 = 10;
 
 SDL_Surface *const srcSurface = imageHelper->create32BitSurface(
 64, 64);
 SDL_Surface *const dstSurface = imageHelper->create32BitSurface(
 512, 512);
 for (int f = 0; f < 64 * 64; f ++)
 static_cast<uint32_t*>(srcSurface->pixels)[f] = 0x11223344;
 clock_gettime(CLOCK_MONOTONIC, &time1);
 for (int d = 0; d < cnt2; d ++)
 {
 for (int f = 0; f < 512 * 512; f ++)
 static_cast<uint32_t*>(dstSurface->pixels)[f] = 0x55667788;
 for (int f = 0; f < cnt1; f ++)
 {
 SDLgfxBlitRGBA(srcSurface,
 nullptr,
 dstSurface,
 nullptr);
 }
 }
 calcTime("blit test",
 "custom time",
 time1,
 time2,
 static_cast<uint32_t*>(dstSurface->pixels));
 
 clock_gettime(CLOCK_MONOTONIC, &time1);
 for (int d = 0; d < cnt2; d ++)
 {
 for (int f = 0; f < 512 * 512; f ++)
 static_cast<uint32_t*>(dstSurface->pixels)[f] = 0x55667788;
 for (int f = 0; f < cnt1; f ++)
 {
 SDL_gfxBlitRGBA(srcSurface,
 nullptr,
 dstSurface,
 nullptr);
 }
 }
 calcTime("blit test",
 "SDL_gfx time",
 time1,
 time2,
 static_cast<uint32_t*>(dstSurface->pixels));
 
#endif // USE_SDL2
#endif // SDL_BYTEORDER == SDL_LIL_ENDIAN
#endif // defined __linux__ || defined __linux
 return 0;
}
 
int TestLauncher::testStackSpeed()
{
/*
 const int sz = 100000;
 const int k = 100;
 const int sz2 = sz * k;
 
 std::stack<ClipRect> stack1;
 MStack<ClipRect> stack2(sz2);
 timespec time1;
 timespec time2;
 
#if defined __linux__ || defined __linux
 for (int d = 0; d < 100; d ++)
 {
 for (int f = 0; f < sz; f ++)
 {
 ClipRect rect;
 rect.xOffset = f;
 rect.yOffset = f;
 stack1.push(rect);
 }
 }
 while (!stack1.empty())
 stack1.pop();
 
 clock_gettime(CLOCK_MONOTONIC, &time1);
 
 for (int d = 0; d < 100; d ++)
 {
 for (int f = 0; f < sz; f ++)
 {
 ClipRect rect;
 rect.xOffset = f;
 rect.yOffset = f;
 stack1.push(rect);
 }
 }
 
 clock_gettime(CLOCK_MONOTONIC, &time2);
 long diff = ((static_cast<long int>(time2.tv_sec) * 1000000000L
 + static_cast<long int>(time2.tv_nsec)) / 1) -
 ((static_cast<long int>(time1.tv_sec) * 1000000000L
 + static_cast<long int>(time1.tv_nsec)) / 1);
 printf("debug: %d\n", stack1.top().xOffset);
 printf("stl time: %ld\n", diff);
 
 for (int d = 0; d < 100; d ++)
 {
 for (int f = 0; f < sz; f ++)
 {
 ClipRect &rect = stack2.push();
 rect.xOffset = f;
 rect.yOffset = f;
 }
 }
 stack2.clear();
 
 clock_gettime(CLOCK_MONOTONIC, &time1);
 
 for (int d = 0; d < 100; d ++)
 {
 for (int f = 0; f < sz; f ++)
 {
 ClipRect &rect = stack2.push();
 rect.xOffset = f;
 rect.yOffset = f;
 }
 }
 
 clock_gettime(CLOCK_MONOTONIC, &time2);
 diff = ((static_cast<long int>(time2.tv_sec) * 1000000000L
 + static_cast<long int>(time2.tv_nsec)) / 1) -
 ((static_cast<long int>(time1.tv_sec) * 1000000000L
 + static_cast<long int>(time1.tv_nsec)) / 1);
 printf("debug: %d\n", stack2.top().xOffset);
 printf("my time: %ld\n", diff);
 
#endif
*/
 return 0;
}
 
int TestLauncher::testDraw()
{
 Image *img[3];
 img[0] = Theme::getImageFromTheme("graphics/sprites/arrow_left.png");
 img[1] = Theme::getImageFromTheme("graphics/sprites/arrow_right.png");
 img[2] = Theme::getImageFromTheme("graphics/sprites/arrow_up.png");
 Skin *skin = theme->load("button.xml",
 "button.xml",
 true,
 Theme::getThemePath());
 if (skin == nullptr)
 return 0;
 
 ImageCollection *const col = new ImageCollection;
 ImageCollection *const col2 = new ImageCollection;
 ImageVertexes *const vert = new ImageVertexes;
 vert->image = img[2];
 
 mainGraphics->pushClipArea(Rect(10, 20, 790, 580));
 mainGraphics->setColor(Color(0xFFU, 0xFFU, 0x00U, 0xFFU));
 mainGraphics->drawRectangle(Rect(0, 0, 400, 200));
 
 mainGraphics->setColor(Color(0xFFU, 0x00U, 0x00U, 0xB0U));
 img[0]->setAlpha(0.5F);
 mainGraphics->drawImage(img[0], 190, 383);
 img[0]->setAlpha(1.0F);
 
 mainGraphics->calcWindow(col2,
 5, 40,
 500, 40,
 skin->getBorder());
 mainGraphics->finalize(col2);
 
 mainGraphics->calcTileVertexes(vert, img[2], 10, 10);
 mainGraphics->calcTileVertexes(vert, img[2], 40, 10);
 mainGraphics->finalize(vert);
 
 mainGraphics->setColor(Color(0x80U, 0x00U, 0xA0U, 0x90U));
 mainGraphics->fillRectangle(Rect(200, 100, 300, 300));
 mainGraphics->popClipArea();
 
 Color color(0xFFU, 0x00U, 0x00U, 0xB0U);
 Color color2(0x00U, 0xFFU, 0x00U, 0xB0U);
 boldFont->drawString(mainGraphics,
 color, color2,
 "test test test test test test test test ", 300, 100);
 
 mainGraphics->drawTileCollection(col2);
 
 mainGraphics->drawPattern(img[0], 10, 400, 300, 180);
 
 mainGraphics->calcPattern(col, img[1], 500, 400, 150, 100);
 mainGraphics->finalize(col);
 
 mainGraphics->drawTileVertexes(vert);
 
 mainGraphics->drawRescaledImage(img[0], 250, 350, 35, 90);
 
 mainGraphics->setColor(Color(0x00U, 0xFFU, 0x00U, 0x90U));
 mainGraphics->drawNet(450, 10, 600, 300, 32, 20);
 
 mainGraphics->drawTileCollection(col);
 
 img[0]->setAlpha(0.3F);
 mainGraphics->drawRescaledPattern(img[0], 250, 150, 250, 300, 30, 100);
 
 for (int f = 0; f < 255; f ++)
 {
 mainGraphics->setColor(Color(0x20U, 0x60U, f, 0x90U));
 mainGraphics->drawLine(300 + f, 490, 300 + f, 480);
 for (int d = 0; d < 10; d ++)
 mainGraphics->drawPoint(300 + f, 500 + d);
 }
 mainGraphics->updateScreen();
 sleep(10);
 
 delete col;
 delete col2;
 delete vert;
 return 0;
}
 
int TestLauncher::testVideoDetection()
{
 file << mTest << std::endl;
 file << graphicsManager.detectGraphics() << std::endl;
 return 0;
}
 
int TestLauncher::calcFps(const timeval &start,
 const timeval &end,
 const int calls) const
{
 long mtime;
 long seconds;
 long useconds;
 
 seconds = end.tv_sec - start.tv_sec;
 useconds = end.tv_usec - start.tv_usec;
 
 mtime = (seconds * 1000 + useconds / 1000.0) + 0.5;
 if (mtime == 0)
 return 100000;
 
 return CAST_S32(static_cast<long>(calls) * 10000 / mtime);
}
 
#endif // USE_OPENGL