[1] | 1 | /** @file
|
---|
| 2 | *
|
---|
| 3 | * VBox frontends: VBoxSDL (simple frontend based on SDL):
|
---|
| 4 | * VBoxSDL testcases
|
---|
| 5 | */
|
---|
| 6 |
|
---|
| 7 | /*
|
---|
[28800] | 8 | * Copyright (C) 2006-2007 Oracle Corporation
|
---|
[1] | 9 | *
|
---|
| 10 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
| 11 | * available from http://www.virtualbox.org. This file is free software;
|
---|
| 12 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
[5999] | 13 | * General Public License (GPL) as published by the Free Software
|
---|
| 14 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
| 15 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
| 16 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
[1] | 17 | */
|
---|
| 18 |
|
---|
[3669] | 19 | #if defined(RT_OS_WINDOWS) ///@todo someone please explain why we don't follow the book!
|
---|
[1] | 20 | # define _SDL_main_h
|
---|
| 21 | #endif
|
---|
| 22 | #include <SDL.h>
|
---|
| 23 |
|
---|
| 24 | #include <iprt/assert.h>
|
---|
[5107] | 25 | #include <iprt/env.h>
|
---|
[1] | 26 | #include <iprt/stream.h>
|
---|
| 27 | #include <iprt/string.h>
|
---|
| 28 | #include <iprt/time.h>
|
---|
| 29 |
|
---|
[5108] | 30 | #include <stdlib.h>
|
---|
[1] | 31 | #include <signal.h>
|
---|
| 32 |
|
---|
| 33 | #ifdef VBOX_OPENGL
|
---|
| 34 | #include "SDL_opengl.h"
|
---|
| 35 | #endif
|
---|
| 36 |
|
---|
[3669] | 37 | #ifdef RT_OS_WINDOWS
|
---|
[1] | 38 | #define ESC_NORM
|
---|
| 39 | #define ESC_BOLD
|
---|
| 40 | #else
|
---|
| 41 | #define ESC_NORM "\033[m"
|
---|
| 42 | #define ESC_BOLD "\033[1m"
|
---|
| 43 | #endif
|
---|
| 44 |
|
---|
| 45 | static SDL_Surface *gSurfVRAM; /* SDL virtual framebuffer surface */
|
---|
| 46 | static void *gPtrVRAM; /* allocated virtual framebuffer */
|
---|
| 47 | static SDL_Surface *gScreen; /* SDL screen surface */
|
---|
| 48 | static unsigned long guGuestXRes; /* virtual framebuffer width */
|
---|
| 49 | static unsigned long guGuestYRes; /* virtual framebuffer height */
|
---|
| 50 | static unsigned long guGuestBpp; /* virtual framebuffer bits per pixel */
|
---|
| 51 | static unsigned long guMaxScreenWidth; /* max screen width SDL allows */
|
---|
| 52 | static unsigned long guMaxScreenHeight; /* max screen height SDL allows */
|
---|
| 53 | static int gfResizable = 1; /* SDL window is resizable */
|
---|
| 54 | static int gfFullscreen = 0; /* use fullscreen mode */
|
---|
| 55 | #ifdef VBOX_OPENGL
|
---|
| 56 | static unsigned long guTextureWidth; /* width of OpenGL texture */
|
---|
| 57 | static unsigned long guTextureHeight; /* height of OpenGL texture */
|
---|
| 58 | static unsigned int gTexture;
|
---|
| 59 | static int gfOpenGL; /* use OpenGL as backend */
|
---|
| 60 | #endif
|
---|
| 61 | static unsigned int guLoop = 1000; /* Number of frame redrawings for each test */
|
---|
| 62 |
|
---|
| 63 | static void bench(unsigned long w, unsigned long h, unsigned long bpp);
|
---|
| 64 | static void benchExecute(void);
|
---|
| 65 | static int checkSDL(const char *fn, int rc);
|
---|
| 66 | static void checkEvents(void);
|
---|
| 67 |
|
---|
| 68 | int
|
---|
| 69 | main(int argc, char **argv)
|
---|
| 70 | {
|
---|
| 71 | int rc;
|
---|
| 72 |
|
---|
| 73 | for (int i = 1; i < argc; i++)
|
---|
| 74 | {
|
---|
| 75 | #ifdef VBOX_OPENGL
|
---|
| 76 | if (strcmp(argv[i], "-gl") == 0)
|
---|
| 77 | {
|
---|
| 78 | gfOpenGL = 1;
|
---|
| 79 | continue;
|
---|
| 80 | }
|
---|
| 81 | #endif
|
---|
| 82 | if (strcmp(argv[i], "-loop") == 0 && ++i < argc)
|
---|
| 83 | {
|
---|
| 84 | guLoop = atoi(argv[i]);
|
---|
| 85 | continue;
|
---|
| 86 | }
|
---|
| 87 | RTPrintf("Unrecognized option '%s'\n", argv[i]);
|
---|
| 88 | return -1;
|
---|
| 89 | }
|
---|
| 90 |
|
---|
[3669] | 91 | #ifdef RT_OS_WINDOWS
|
---|
[1] | 92 | /* Default to DirectX if nothing else set. "windib" would be possible. */
|
---|
[25942] | 93 | if (!RTEnvExist("SDL_VIDEODRIVER"))
|
---|
[1] | 94 | {
|
---|
| 95 | _putenv("SDL_VIDEODRIVER=directx");
|
---|
| 96 | }
|
---|
| 97 | #endif
|
---|
| 98 |
|
---|
[3669] | 99 | #ifdef RT_OS_WINDOWS
|
---|
[1] | 100 | _putenv("SDL_VIDEO_WINDOW_POS=0,0");
|
---|
| 101 | #else
|
---|
[11419] | 102 | RTEnvSet("SDL_VIDEO_WINDOW_POS", "0,0");
|
---|
[1] | 103 | #endif
|
---|
| 104 |
|
---|
| 105 | rc = SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_NOPARACHUTE);
|
---|
| 106 | if (rc != 0)
|
---|
| 107 | {
|
---|
| 108 | RTPrintf("Error: SDL_InitSubSystem failed with message '%s'\n", SDL_GetError());
|
---|
| 109 | return -1;
|
---|
| 110 | }
|
---|
| 111 |
|
---|
| 112 | /* output what SDL is capable of */
|
---|
| 113 | const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
|
---|
| 114 |
|
---|
| 115 | if (!videoInfo)
|
---|
| 116 | {
|
---|
| 117 | RTPrintf("No SDL video info available!\n");
|
---|
| 118 | return -1;
|
---|
| 119 | }
|
---|
| 120 |
|
---|
| 121 | RTPrintf("SDL capabilities:\n");
|
---|
| 122 | RTPrintf(" Hardware surface support: %s\n", videoInfo->hw_available ? "yes" : "no");
|
---|
| 123 | RTPrintf(" Window manager available: %s\n", videoInfo->wm_available ? "yes" : "no");
|
---|
| 124 | RTPrintf(" Screen to screen blits accelerated: %s\n", videoInfo->blit_hw ? "yes" : "no");
|
---|
| 125 | RTPrintf(" Screen to screen colorkey blits accelerated: %s\n", videoInfo->blit_hw_CC ? "yes" : "no");
|
---|
| 126 | RTPrintf(" Screen to screen alpha blits accelerated: %s\n", videoInfo->blit_hw_A ? "yes" : "no");
|
---|
| 127 | RTPrintf(" Memory to screen blits accelerated: %s\n", videoInfo->blit_sw ? "yes" : "no");
|
---|
| 128 | RTPrintf(" Memory to screen colorkey blits accelerated: %s\n", videoInfo->blit_sw_CC ? "yes" : "no");
|
---|
| 129 | RTPrintf(" Memory to screen alpha blits accelerated: %s\n", videoInfo->blit_sw_A ? "yes" : "no");
|
---|
| 130 | RTPrintf(" Color fills accelerated: %s\n", videoInfo->blit_fill ? "yes" : "no");
|
---|
| 131 | RTPrintf(" Video memory in kilobytes: %d\n", videoInfo->video_mem);
|
---|
| 132 | RTPrintf(" Optimal bpp mode: %d\n", videoInfo->vfmt->BitsPerPixel);
|
---|
| 133 | char buf[256];
|
---|
[5107] | 134 | RTPrintf("Video driver SDL_VIDEODRIVER / active: %s/%s\n", RTEnvGet("SDL_VIDEODRIVER"),
|
---|
[1] | 135 | SDL_VideoDriverName(buf, sizeof(buf)));
|
---|
| 136 |
|
---|
| 137 | RTPrintf("\n"
|
---|
| 138 | "Starting tests. Any key pressed inside the SDL window will abort this\n"
|
---|
| 139 | "program at the end of the current test. Iterations = %u\n", guLoop);
|
---|
| 140 |
|
---|
| 141 | #ifdef VBOX_OPENGL
|
---|
| 142 | RTPrintf("\n========== "ESC_BOLD"OpenGL is %s"ESC_NORM" ==========\n",
|
---|
| 143 | gfOpenGL ? "ON" : "OFF");
|
---|
| 144 | #endif
|
---|
| 145 | bench( 640, 480, 16); bench( 640, 480, 24); bench( 640, 480, 32);
|
---|
| 146 | bench(1024, 768, 16); bench(1024, 768, 24); bench(1024, 768, 32);
|
---|
| 147 | bench(1280, 1024, 16); bench(1280, 1024, 24); bench(1280, 1024, 32);
|
---|
| 148 |
|
---|
| 149 | RTPrintf("\nSuccess!\n");
|
---|
[613] | 150 | return 0;
|
---|
[1] | 151 | }
|
---|
| 152 |
|
---|
| 153 | /**
|
---|
| 154 | * Method that does the actual resize of the guest framebuffer and
|
---|
| 155 | * then changes the SDL framebuffer setup.
|
---|
| 156 | */
|
---|
| 157 | static void bench(unsigned long w, unsigned long h, unsigned long bpp)
|
---|
| 158 | {
|
---|
| 159 | Uint32 Rmask, Gmask, Bmask, Amask = 0;
|
---|
| 160 | Uint32 Rsize, Gsize, Bsize;
|
---|
| 161 | Uint32 newWidth, newHeight;
|
---|
| 162 |
|
---|
| 163 | guGuestXRes = w;
|
---|
| 164 | guGuestYRes = h;
|
---|
| 165 | guGuestBpp = bpp;
|
---|
| 166 |
|
---|
| 167 | RTPrintf("\n");
|
---|
| 168 |
|
---|
| 169 | /* a different format we support directly? */
|
---|
| 170 | switch (guGuestBpp)
|
---|
| 171 | {
|
---|
| 172 | case 16:
|
---|
| 173 | {
|
---|
| 174 | Rmask = 0xF800;
|
---|
| 175 | Gmask = 0x07E0;
|
---|
| 176 | Bmask = 0x001F;
|
---|
| 177 | Amask = 0x0000;
|
---|
| 178 | Rsize = 5;
|
---|
| 179 | Gsize = 6;
|
---|
| 180 | Bsize = 5;
|
---|
| 181 | break;
|
---|
| 182 | }
|
---|
| 183 |
|
---|
| 184 | case 24:
|
---|
| 185 | {
|
---|
| 186 | Rmask = 0x00FF0000;
|
---|
| 187 | Gmask = 0x0000FF00;
|
---|
| 188 | Bmask = 0x000000FF;
|
---|
| 189 | Amask = 0x00000000;
|
---|
| 190 | Rsize = 8;
|
---|
| 191 | Gsize = 8;
|
---|
| 192 | Bsize = 8;
|
---|
| 193 | break;
|
---|
| 194 | }
|
---|
| 195 |
|
---|
| 196 | default:
|
---|
| 197 | Rmask = 0x00FF0000;
|
---|
| 198 | Gmask = 0x0000FF00;
|
---|
| 199 | Bmask = 0x000000FF;
|
---|
| 200 | Amask = 0x00000000;
|
---|
| 201 | Rsize = 8;
|
---|
| 202 | Gsize = 8;
|
---|
| 203 | Bsize = 8;
|
---|
| 204 | break;
|
---|
| 205 | }
|
---|
| 206 |
|
---|
| 207 | int sdlFlags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
|
---|
| 208 | #ifdef VBOX_OPENGL
|
---|
| 209 | if (gfOpenGL)
|
---|
| 210 | sdlFlags |= SDL_OPENGL;
|
---|
| 211 | #endif
|
---|
| 212 | if (gfResizable)
|
---|
| 213 | sdlFlags |= SDL_RESIZABLE;
|
---|
| 214 | if (gfFullscreen)
|
---|
| 215 | sdlFlags |= SDL_FULLSCREEN;
|
---|
| 216 |
|
---|
| 217 | /*
|
---|
| 218 | * Now we have to check whether there are video mode restrictions
|
---|
| 219 | */
|
---|
| 220 | SDL_Rect **modes;
|
---|
| 221 | /* Get available fullscreen/hardware modes */
|
---|
| 222 | modes = SDL_ListModes(NULL, sdlFlags);
|
---|
| 223 | if (modes == NULL)
|
---|
| 224 | {
|
---|
| 225 | RTPrintf("Error: SDL_ListModes failed with message '%s'\n", SDL_GetError());
|
---|
| 226 | return;
|
---|
| 227 | }
|
---|
| 228 |
|
---|
| 229 | /* -1 means that any mode is possible (usually non fullscreen) */
|
---|
| 230 | if (modes != (SDL_Rect **)-1)
|
---|
| 231 | {
|
---|
| 232 | /*
|
---|
| 233 | * according to the SDL documentation, the API guarantees that
|
---|
| 234 | * the modes are sorted from larger to smaller, so we just
|
---|
| 235 | * take the first entry as the maximum.
|
---|
| 236 | */
|
---|
| 237 | guMaxScreenWidth = modes[0]->w;
|
---|
| 238 | guMaxScreenHeight = modes[0]->h;
|
---|
| 239 | }
|
---|
| 240 | else
|
---|
| 241 | {
|
---|
| 242 | /* no restriction */
|
---|
| 243 | guMaxScreenWidth = ~0;
|
---|
| 244 | guMaxScreenHeight = ~0;
|
---|
| 245 | }
|
---|
| 246 |
|
---|
| 247 | newWidth = RT_MIN(guMaxScreenWidth, guGuestXRes);
|
---|
| 248 | newHeight = RT_MIN(guMaxScreenHeight, guGuestYRes);
|
---|
| 249 |
|
---|
| 250 | /*
|
---|
| 251 | * Now set the screen resolution and get the surface pointer
|
---|
| 252 | * @todo BPP is not supported!
|
---|
| 253 | */
|
---|
| 254 | #ifdef VBOX_OPENGL
|
---|
| 255 | if (gfOpenGL)
|
---|
| 256 | {
|
---|
| 257 | checkSDL("SDL_GL_SetAttribute", SDL_GL_SetAttribute(SDL_GL_RED_SIZE, Rsize));
|
---|
| 258 | checkSDL("SDL_GL_SetAttribute", SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, Gsize));
|
---|
| 259 | checkSDL("SDL_GL_SetAttribute", SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, Bsize));
|
---|
| 260 | checkSDL("SDL_GL_SetAttribute", SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0));
|
---|
| 261 | }
|
---|
| 262 | #endif
|
---|
| 263 |
|
---|
| 264 | RTPrintf("Testing "ESC_BOLD"%ldx%ld@%ld"ESC_NORM"\n", guGuestXRes, guGuestYRes, guGuestBpp);
|
---|
| 265 |
|
---|
| 266 | gScreen = SDL_SetVideoMode(newWidth, newHeight, 0, sdlFlags);
|
---|
| 267 | if (!gScreen)
|
---|
| 268 | {
|
---|
| 269 | RTPrintf("SDL_SetVideoMode failed (%s)\n", SDL_GetError());
|
---|
| 270 | return;
|
---|
| 271 | }
|
---|
| 272 |
|
---|
| 273 | /* first free the current surface */
|
---|
| 274 | if (gSurfVRAM)
|
---|
| 275 | {
|
---|
| 276 | SDL_FreeSurface(gSurfVRAM);
|
---|
| 277 | gSurfVRAM = NULL;
|
---|
| 278 | }
|
---|
| 279 | if (gPtrVRAM)
|
---|
| 280 | {
|
---|
| 281 | free(gPtrVRAM);
|
---|
| 282 | gPtrVRAM = NULL;
|
---|
| 283 | }
|
---|
| 284 |
|
---|
| 285 | if (gScreen->format->BitsPerPixel != guGuestBpp)
|
---|
| 286 | {
|
---|
| 287 | /* Create a source surface from guest VRAM. */
|
---|
| 288 | int bytes_per_pixel = (guGuestBpp + 7) / 8;
|
---|
| 289 | gPtrVRAM = malloc(guGuestXRes * guGuestYRes * bytes_per_pixel);
|
---|
| 290 | gSurfVRAM = SDL_CreateRGBSurfaceFrom(gPtrVRAM, guGuestXRes, guGuestYRes, guGuestBpp,
|
---|
| 291 | bytes_per_pixel * guGuestXRes,
|
---|
| 292 | Rmask, Gmask, Bmask, Amask);
|
---|
| 293 | }
|
---|
| 294 | else
|
---|
| 295 | {
|
---|
| 296 | /* Create a software surface for which SDL allocates the RAM */
|
---|
| 297 | gSurfVRAM = SDL_CreateRGBSurface(SDL_SWSURFACE, guGuestXRes, guGuestYRes, guGuestBpp,
|
---|
| 298 | Rmask, Gmask, Bmask, Amask);
|
---|
| 299 | }
|
---|
| 300 |
|
---|
| 301 | if (!gSurfVRAM)
|
---|
| 302 | {
|
---|
| 303 | RTPrintf("Failed to allocate surface %ldx%ld@%ld\n",
|
---|
| 304 | guGuestXRes, guGuestYRes, guGuestBpp);
|
---|
| 305 | return;
|
---|
| 306 | }
|
---|
| 307 |
|
---|
| 308 | RTPrintf(" gScreen=%dx%d@%d (surface: %s)\n",
|
---|
| 309 | gScreen->w, gScreen->h, gScreen->format->BitsPerPixel,
|
---|
| 310 | (gScreen->flags & SDL_HWSURFACE) == 0 ? "software" : "hardware");
|
---|
| 311 |
|
---|
| 312 | SDL_Rect rect = { 0, 0, (Uint16)guGuestXRes, (Uint16)guGuestYRes };
|
---|
| 313 | checkSDL("SDL_FillRect",
|
---|
| 314 | SDL_FillRect(gSurfVRAM, &rect,
|
---|
| 315 | SDL_MapRGB(gSurfVRAM->format, 0x5F, 0x6F, 0x1F)));
|
---|
| 316 |
|
---|
| 317 | #ifdef VBOX_OPENGL
|
---|
| 318 | if (gfOpenGL)
|
---|
| 319 | {
|
---|
| 320 | int r, g, b, d, o;
|
---|
| 321 | SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &r);
|
---|
| 322 | SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &g);
|
---|
| 323 | SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &b);
|
---|
| 324 | SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &d);
|
---|
| 325 | SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &o);
|
---|
| 326 | RTPrintf(" OpenGL ctxt red=%d, green=%d, blue=%d, depth=%d, dbl=%d", r, g, b, d, o);
|
---|
| 327 |
|
---|
| 328 | glEnable(GL_TEXTURE_2D);
|
---|
| 329 | glDisable(GL_BLEND);
|
---|
| 330 | glDisable(GL_DEPTH_TEST);
|
---|
| 331 | glDepthMask(GL_FALSE);
|
---|
| 332 | glGenTextures(1, &gTexture);
|
---|
| 333 | glBindTexture(GL_TEXTURE_2D, gTexture);
|
---|
| 334 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
---|
| 335 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
---|
| 336 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
|
---|
| 337 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
|
---|
| 338 |
|
---|
[12918] | 339 | for (guTextureWidth = 32; guTextureWidth < newWidth; guTextureWidth <<= 1)
|
---|
| 340 | ;
|
---|
| 341 | for (guTextureHeight = 32; guTextureHeight < newHeight; guTextureHeight <<= 1)
|
---|
| 342 | ;
|
---|
[1] | 343 | RTPrintf(", tex %ldx%ld\n", guTextureWidth, guTextureHeight);
|
---|
| 344 |
|
---|
| 345 | switch (guGuestBpp)
|
---|
| 346 | {
|
---|
| 347 | case 16: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, guTextureWidth, guTextureHeight, 0,
|
---|
| 348 | GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0);
|
---|
| 349 | break;
|
---|
| 350 | case 24: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, guTextureWidth, guTextureHeight, 0,
|
---|
| 351 | GL_BGR, GL_UNSIGNED_BYTE, 0);
|
---|
| 352 | break;
|
---|
| 353 | case 32: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, guTextureWidth, guTextureHeight, 0,
|
---|
| 354 | GL_BGRA, GL_UNSIGNED_BYTE, 0);
|
---|
| 355 | break;
|
---|
| 356 | default: RTPrintf("guGuestBpp=%d?\n", guGuestBpp);
|
---|
| 357 | return;
|
---|
| 358 | }
|
---|
| 359 |
|
---|
| 360 | glViewport(0, 0, newWidth, newHeight);
|
---|
| 361 | glMatrixMode(GL_PROJECTION);
|
---|
| 362 | glLoadIdentity();
|
---|
| 363 | glOrtho(0.0, newWidth, newHeight, 0.0, -1.0, 1.0);
|
---|
| 364 | }
|
---|
| 365 | #endif
|
---|
| 366 |
|
---|
| 367 | checkEvents();
|
---|
| 368 | benchExecute();
|
---|
| 369 |
|
---|
| 370 | #ifdef VBOX_OPENGL
|
---|
| 371 | if (gfOpenGL)
|
---|
| 372 | {
|
---|
| 373 | glDeleteTextures(1, &gTexture);
|
---|
| 374 | }
|
---|
| 375 | #endif
|
---|
| 376 | }
|
---|
| 377 |
|
---|
| 378 | static void benchExecute()
|
---|
| 379 | {
|
---|
| 380 | SDL_Rect rect = { 0, 0, (Uint16)guGuestXRes, (Uint16)guGuestYRes };
|
---|
| 381 | RTTIMESPEC t1, t2;
|
---|
| 382 |
|
---|
| 383 | RTTimeNow(&t1);
|
---|
| 384 | for (unsigned i=0; i<guLoop; i++)
|
---|
| 385 | {
|
---|
| 386 | #ifdef VBOX_OPENGL
|
---|
| 387 | if (!gfOpenGL)
|
---|
| 388 | {
|
---|
| 389 | #endif
|
---|
| 390 | /* SDL backend */
|
---|
| 391 | checkSDL("SDL_BlitSurface", SDL_BlitSurface(gSurfVRAM, &rect, gScreen, &rect));
|
---|
| 392 | if ((gScreen->flags & SDL_HWSURFACE) == 0)
|
---|
| 393 | SDL_UpdateRect(gScreen, rect.x, rect.y, rect.w, rect.h);
|
---|
| 394 | #ifdef VBOX_OPENGL
|
---|
| 395 | }
|
---|
| 396 | else
|
---|
| 397 | {
|
---|
| 398 | /* OpenGL backend */
|
---|
| 399 | glBindTexture(GL_TEXTURE_2D, gTexture);
|
---|
| 400 | glPixelStorei(GL_UNPACK_SKIP_PIXELS, rect.x);
|
---|
| 401 | glPixelStorei(GL_UNPACK_SKIP_ROWS, rect.y);
|
---|
| 402 | glPixelStorei(GL_UNPACK_ROW_LENGTH, gSurfVRAM->pitch / gSurfVRAM->format->BytesPerPixel);
|
---|
| 403 | switch (gSurfVRAM->format->BitsPerPixel)
|
---|
| 404 | {
|
---|
| 405 | case 16: glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rect.w, rect.h,
|
---|
| 406 | GL_RGB, GL_UNSIGNED_SHORT_5_6_5, gSurfVRAM->pixels);
|
---|
| 407 | break;
|
---|
| 408 | case 24: glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rect.w, rect.h,
|
---|
| 409 | GL_BGR, GL_UNSIGNED_BYTE, gSurfVRAM->pixels);
|
---|
| 410 | break;
|
---|
| 411 | case 32: glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rect.w, rect.h,
|
---|
| 412 | GL_BGRA, GL_UNSIGNED_BYTE, gSurfVRAM->pixels);
|
---|
| 413 | break;
|
---|
| 414 | default: RTPrintf("BitsPerPixel=%d?\n", gSurfVRAM->format->BitsPerPixel);
|
---|
| 415 | return;
|
---|
| 416 | }
|
---|
| 417 | GLfloat tx = (GLfloat)((float)rect.w) / guTextureWidth;
|
---|
| 418 | GLfloat ty = (GLfloat)((float)rect.h) / guTextureHeight;
|
---|
| 419 | glBegin(GL_QUADS);
|
---|
| 420 | glColor4f(1.0, 1.0, 1.0, 1.0);
|
---|
| 421 | glTexCoord2f(0.0, 0.0); glVertex2i(rect.x, rect.y );
|
---|
| 422 | glTexCoord2f(0.0, ty); glVertex2i(rect.x, rect.y + rect.h);
|
---|
| 423 | glTexCoord2f(tx, ty); glVertex2i(rect.x + rect.w, rect.y + rect.h);
|
---|
| 424 | glTexCoord2f(tx, 0.0); glVertex2i(rect.x + rect.w, rect.y );
|
---|
| 425 | glEnd();
|
---|
| 426 | glFlush();
|
---|
| 427 | }
|
---|
| 428 | #endif
|
---|
| 429 | }
|
---|
| 430 | RTTimeNow(&t2);
|
---|
| 431 | int64_t ms = RTTimeSpecGetMilli(&t2) - RTTimeSpecGetMilli(&t1);
|
---|
| 432 | printf(" %.1fms/frame\n", (double)ms / guLoop);
|
---|
| 433 | }
|
---|
| 434 |
|
---|
| 435 | static int checkSDL(const char *fn, int rc)
|
---|
| 436 | {
|
---|
| 437 | if (rc == -1)
|
---|
| 438 | RTPrintf(""ESC_BOLD"%s() failed:"ESC_NORM" '%s'\n", fn, SDL_GetError());
|
---|
| 439 |
|
---|
| 440 | return rc;
|
---|
| 441 | }
|
---|
| 442 |
|
---|
| 443 | static void checkEvents(void)
|
---|
| 444 | {
|
---|
| 445 | SDL_Event event;
|
---|
| 446 | while (SDL_PollEvent(&event))
|
---|
| 447 | {
|
---|
| 448 | switch (event.type)
|
---|
| 449 | {
|
---|
| 450 | case SDL_KEYDOWN:
|
---|
| 451 | RTPrintf("\nKey pressed, exiting ...\n");
|
---|
| 452 | exit(-1);
|
---|
| 453 | break;
|
---|
| 454 | }
|
---|
| 455 | }
|
---|
| 456 | }
|
---|