1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2012 Sam Lantinga 4 5 This library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public 7 License as published by the Free Software Foundation; either 8 version 2.1 of the License, or (at your option) any later version. 9 10 This library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 19 Sam Lantinga 20 slouken (at) libsdl.org 21 */ 22 #include "SDL_config.h" 23 24 /* BWindow based framebuffer implementation */ 25 26 #include <unistd.h> 27 28 #include "SDL_BWin.h" 29 #include "SDL_timer.h" 30 31 extern "C" { 32 33 #include "../SDL_sysvideo.h" 34 #include "../../events/SDL_events_c.h" 35 #include "SDL_sysevents_c.h" 36 #include "SDL_sysmouse_c.h" 37 #include "SDL_syswm_c.h" 38 #include "SDL_lowvideo.h" 39 #include "../SDL_yuvfuncs.h" 40 #include "SDL_sysyuv.h" 41 #include "../blank_cursor.h" 42 43 #define BEOS_HIDDEN_SIZE 32 /* starting hidden window size */ 44 45 /* Initialization/Query functions */ 46 static int BE_VideoInit(_THIS, SDL_PixelFormat *vformat); 47 static SDL_Rect **BE_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); 48 static SDL_Surface *BE_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); 49 static void BE_UpdateMouse(_THIS); 50 static int BE_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); 51 static void BE_VideoQuit(_THIS); 52 53 /* Hardware surface functions */ 54 static int BE_AllocHWSurface(_THIS, SDL_Surface *surface); 55 static int BE_LockHWSurface(_THIS, SDL_Surface *surface); 56 static void BE_UnlockHWSurface(_THIS, SDL_Surface *surface); 57 static void BE_FreeHWSurface(_THIS, SDL_Surface *surface); 58 59 static int BE_ToggleFullScreen(_THIS, int fullscreen); 60 61 /* OpenGL functions */ 62 #if SDL_VIDEO_OPENGL 63 static int BE_GL_LoadLibrary(_THIS, const char *path); 64 static void* BE_GL_GetProcAddress(_THIS, const char *proc); 65 static int BE_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value); 66 static int BE_GL_MakeCurrent(_THIS); 67 static void BE_GL_SwapBuffers(_THIS); 68 #endif 69 70 /* FB driver bootstrap functions */ 71 72 static int BE_Available(void) 73 { 74 return(1); 75 } 76 77 static void BE_DeleteDevice(SDL_VideoDevice *device) 78 { 79 SDL_free(device->hidden); 80 SDL_free(device); 81 } 82 83 static SDL_VideoDevice *BE_CreateDevice(int devindex) 84 { 85 SDL_VideoDevice *device; 86 87 /* Initialize all variables that we clean on shutdown */ 88 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); 89 if ( device ) { 90 SDL_memset(device, 0, (sizeof *device)); 91 device->hidden = (struct SDL_PrivateVideoData *) 92 SDL_malloc((sizeof *device->hidden)); 93 } 94 if ( (device == NULL) || (device->hidden == NULL) ) { 95 SDL_OutOfMemory(); 96 if ( device ) { 97 SDL_free(device); 98 } 99 return(0); 100 } 101 SDL_memset(device->hidden, 0, (sizeof *device->hidden)); 102 103 /* Set the function pointers */ 104 /* Initialization/Query functions */ 105 device->VideoInit = BE_VideoInit; 106 device->ListModes = BE_ListModes; 107 device->SetVideoMode = BE_SetVideoMode; 108 device->ToggleFullScreen = BE_ToggleFullScreen; 109 device->UpdateMouse = BE_UpdateMouse; 110 device->CreateYUVOverlay = BE_CreateYUVOverlay; 111 device->SetColors = BE_SetColors; 112 device->UpdateRects = NULL; 113 device->VideoQuit = BE_VideoQuit; 114 /* Hardware acceleration functions */ 115 device->AllocHWSurface = BE_AllocHWSurface; 116 device->CheckHWBlit = NULL; 117 device->FillHWRect = NULL; 118 device->SetHWColorKey = NULL; 119 device->SetHWAlpha = NULL; 120 device->LockHWSurface = BE_LockHWSurface; 121 device->UnlockHWSurface = BE_UnlockHWSurface; 122 device->FlipHWSurface = NULL; 123 device->FreeHWSurface = BE_FreeHWSurface; 124 /* Gamma support */ 125 #if SDL_VIDEO_OPENGL 126 /* OpenGL support */ 127 device->GL_LoadLibrary = BE_GL_LoadLibrary; 128 device->GL_GetProcAddress = BE_GL_GetProcAddress; 129 device->GL_GetAttribute = BE_GL_GetAttribute; 130 device->GL_MakeCurrent = BE_GL_MakeCurrent; 131 device->GL_SwapBuffers = BE_GL_SwapBuffers; 132 #endif 133 /* Window manager functions */ 134 device->SetCaption = BE_SetWMCaption; 135 device->SetIcon = NULL; 136 device->IconifyWindow = BE_IconifyWindow; 137 device->GrabInput = BE_GrabInput; 138 device->GetWMInfo = BE_GetWMInfo; 139 /* Cursor manager functions */ 140 device->FreeWMCursor = BE_FreeWMCursor; 141 device->CreateWMCursor = BE_CreateWMCursor; 142 device->ShowWMCursor = BE_ShowWMCursor; 143 device->WarpWMCursor = BE_WarpWMCursor; 144 device->MoveWMCursor = NULL; 145 device->CheckMouseMode = BE_CheckMouseMode; 146 /* Event manager functions */ 147 device->InitOSKeymap = BE_InitOSKeymap; 148 device->PumpEvents = BE_PumpEvents; 149 150 device->free = BE_DeleteDevice; 151 152 /* Set the driver flags */ 153 device->handles_any_size = 1; 154 155 return device; 156 } 157 158 VideoBootStrap BWINDOW_bootstrap = { 159 "bwindow", "BDirectWindow graphics", 160 BE_Available, BE_CreateDevice 161 }; 162 163 static inline int ColorSpaceToBitsPerPixel(uint32 colorspace) 164 { 165 int bitsperpixel; 166 167 bitsperpixel = 0; 168 switch (colorspace) { 169 case B_CMAP8: 170 bitsperpixel = 8; 171 break; 172 case B_RGB15: 173 case B_RGBA15: 174 case B_RGB15_BIG: 175 case B_RGBA15_BIG: 176 bitsperpixel = 15; 177 break; 178 case B_RGB16: 179 case B_RGB16_BIG: 180 bitsperpixel = 16; 181 break; 182 case B_RGB32: 183 case B_RGBA32: 184 case B_RGB32_BIG: 185 case B_RGBA32_BIG: 186 bitsperpixel = 32; 187 break; 188 default: 189 break; 190 } 191 return(bitsperpixel); 192 } 193 194 /* Function to sort the display_list in bscreen */ 195 static int CompareModes(const void *A, const void *B) 196 { 197 const display_mode *a = (display_mode *)A; 198 const display_mode *b = (display_mode *)B; 199 200 if ( a->space == b->space ) { 201 return((b->virtual_width*b->virtual_height)- 202 (a->virtual_width*a->virtual_height)); 203 } else { 204 return(ColorSpaceToBitsPerPixel(b->space)- 205 ColorSpaceToBitsPerPixel(a->space)); 206 } 207 } 208 209 /* Yes, this isn't the fastest it could be, but it works nicely */ 210 static int BE_AddMode(_THIS, int index, unsigned int w, unsigned int h) 211 { 212 SDL_Rect *mode; 213 int i; 214 int next_mode; 215 216 /* Check to see if we already have this mode */ 217 if ( SDL_nummodes[index] > 0 ) { 218 for ( i=SDL_nummodes[index]-1; i >= 0; --i ) { 219 mode = SDL_modelist[index][i]; 220 if ( (mode->w == w) && (mode->h == h) ) { 221 #ifdef BWINDOW_DEBUG 222 fprintf(stderr, "We already have mode %dx%d at %d bytes per pixel\n", w, h, index+1); 223 #endif 224 return(0); 225 } 226 } 227 } 228 229 /* Set up the new video mode rectangle */ 230 mode = (SDL_Rect *)SDL_malloc(sizeof *mode); 231 if ( mode == NULL ) { 232 SDL_OutOfMemory(); 233 return(-1); 234 } 235 mode->x = 0; 236 mode->y = 0; 237 mode->w = w; 238 mode->h = h; 239 #ifdef BWINDOW_DEBUG 240 fprintf(stderr, "Adding mode %dx%d at %d bytes per pixel\n", w, h, index+1); 241 #endif 242 243 /* Allocate the new list of modes, and fill in the new mode */ 244 next_mode = SDL_nummodes[index]; 245 SDL_modelist[index] = (SDL_Rect **) 246 SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); 247 if ( SDL_modelist[index] == NULL ) { 248 SDL_OutOfMemory(); 249 SDL_nummodes[index] = 0; 250 SDL_free(mode); 251 return(-1); 252 } 253 SDL_modelist[index][next_mode] = mode; 254 SDL_modelist[index][next_mode+1] = NULL; 255 SDL_nummodes[index]++; 256 257 return(0); 258 } 259 260 int BE_VideoInit(_THIS, SDL_PixelFormat *vformat) 261 { 262 display_mode *modes; 263 uint32 i, nmodes; 264 int bpp; 265 BRect bounds; 266 267 /* Initialize the Be Application for appserver interaction */ 268 if ( SDL_InitBeApp() < 0 ) { 269 return(-1); 270 } 271 272 /* It is important that this be created after SDL_InitBeApp() */ 273 BScreen bscreen; 274 275 /* Save the current display mode */ 276 bscreen.GetMode(&saved_mode); 277 _this->info.current_w = saved_mode.virtual_width; 278 _this->info.current_h = saved_mode.virtual_height; 279 280 /* Determine the screen depth */ 281 vformat->BitsPerPixel = ColorSpaceToBitsPerPixel(bscreen.ColorSpace()); 282 if ( vformat->BitsPerPixel == 0 ) { 283 SDL_SetError("Unknown BScreen colorspace: 0x%x", 284 bscreen.ColorSpace()); 285 return(-1); 286 } 287 288 /* Get the video modes we can switch to in fullscreen mode */ 289 bscreen.GetModeList(&modes, &nmodes); 290 SDL_qsort(modes, nmodes, sizeof *modes, CompareModes); 291 for ( i=0; i<nmodes; ++i ) { 292 bpp = ColorSpaceToBitsPerPixel(modes[i].space); 293 //if ( bpp != 0 ) { // There are bugs in changing colorspace 294 if ( modes[i].space == saved_mode.space ) { 295 BE_AddMode(_this, ((bpp+7)/8)-1, 296 modes[i].virtual_width, 297 modes[i].virtual_height); 298 } 299 } 300 301 /* Create the window and view */ 302 bounds.top = 0; bounds.left = 0; 303 bounds.right = BEOS_HIDDEN_SIZE; 304 bounds.bottom = BEOS_HIDDEN_SIZE; 305 SDL_Win = new SDL_BWin(bounds); 306 307 #if SDL_VIDEO_OPENGL 308 /* testgl application doesn't load library, just tries to load symbols */ 309 /* is it correct? if so we have to load library here */ 310 BE_GL_LoadLibrary(_this, NULL); 311 #endif 312 313 /* Create the clear cursor */ 314 SDL_BlankCursor = BE_CreateWMCursor(_this, blank_cdata, blank_cmask, 315 BLANK_CWIDTH, BLANK_CHEIGHT, BLANK_CHOTX, BLANK_CHOTY); 316 317 /* Fill in some window manager capabilities */ 318 _this->info.wm_available = 1; 319 320 /* We're done! */ 321 return(0); 322 } 323 324 /* We support any dimension at our bit-depth */ 325 SDL_Rect **BE_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) 326 { 327 SDL_Rect **modes; 328 329 modes = ((SDL_Rect **)0); 330 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 331 modes = SDL_modelist[((format->BitsPerPixel+7)/8)-1]; 332 } else { 333 if ( format->BitsPerPixel == 334 _this->screen->format->BitsPerPixel ) { 335 modes = ((SDL_Rect **)-1); 336 } 337 } 338 return(modes); 339 } 340 341 /* Various screen update functions available */ 342 static void BE_NormalUpdate(_THIS, int numrects, SDL_Rect *rects); 343 344 345 /* Find the closest display mode for fullscreen */ 346 static bool BE_FindClosestFSMode(_THIS, int width, int height, int bpp, 347 display_mode *mode) 348 { 349 BScreen bscreen; 350 uint32 i, nmodes; 351 SDL_Rect **modes; 352 display_mode *dmodes; 353 display_mode current; 354 float current_refresh; 355 bscreen.GetMode(¤t); 356 current_refresh = (1000 * current.timing.pixel_clock) / 357 (current.timing.h_total * current.timing.v_total); 358 359 modes = SDL_modelist[((bpp+7)/8)-1]; 360 361 // find end of list (lowest-resolution mode; modes are ordered 362 // highest-to-lowest). 363 i = 0; while(modes[i]) i++; 364 if (!i) return false; // what? no modes at all? 365 366 // find first mode with resolution >= requested in both dimensions 367 for (--i; i >= 0; --i) 368 { 369 if (modes[i]->w >= width && modes[i]->h >= height) 370 break; 371 } 372 373 // unable to find any mode with that high a resolution! 374 if (i < 0) 375 return false; 376 377 width = modes[i]->w; 378 height = modes[i]->h; 379 380 bscreen.GetModeList(&dmodes, &nmodes); 381 for ( i = 0; i < nmodes; ++i ) { 382 if ( (bpp == ColorSpaceToBitsPerPixel(dmodes[i].space)) && 383 (width == dmodes[i].virtual_width) && 384 (height == dmodes[i].virtual_height) ) { 385 break; 386 } 387 } 388 if ( i != nmodes ) { 389 *mode = dmodes[i]; 390 if ((mode->virtual_width <= current.virtual_width) && 391 (mode->virtual_height <= current.virtual_height)) { 392 float new_refresh = (1000 * mode->timing.pixel_clock) / 393 (mode->timing.h_total * mode->timing.v_total); 394 if (new_refresh < current_refresh) { 395 mode->timing.pixel_clock = (uint32)((mode->timing.h_total * mode->timing.v_total) 396 * current_refresh / 1000); 397 } 398 } 399 return true; 400 } else { 401 return false; 402 } 403 } 404 405 static int BE_SetFullScreen(_THIS, SDL_Surface *screen, int fullscreen) 406 { 407 // printf("SetFullScreen(%d)\n", fullscreen); 408 BScreen bscreen; 409 410 // SetFullSscreen() does not work as expected if called in a window 411 // that was never shown. This is probably a bug in the Haiku Game Kit that needs 412 // to be investigated. 413 if (SDL_Win->Lock()) { 414 // Show our window. 415 SDL_Win->Show(); 416 } 417 418 if (SDL_Win->IsLocked()) { 419 // Unlock the window if it was locked. This is needed as only the 420 // first call to Show() unlocks the looper. All other calls to it 421 // will not. 422 SDL_Win->Unlock(); 423 } 424 425 int width = screen->w; 426 int height = screen->h; 427 428 if (fullscreen) { 429 // Set resolution to the closest available one that matches the 430 // current SDL resolution. 431 display_mode mode; 432 bscreen.GetMode(&mode); 433 434 int bpp = screen->format->BitsPerPixel; 435 if (bpp != ColorSpaceToBitsPerPixel(mode.space) || 436 width != mode.virtual_width || height != mode.virtual_height) { 437 if(BE_FindClosestFSMode(_this, width, height, bpp, &mode)) { 438 bscreen.SetMode(&mode); 439 } else { 440 // printf("Could not set new mode.\n"); 441 return(0); 442 } 443 } 444 } else { 445 // Reset to the previous known resolution as we are now in window 446 // mode. 447 bscreen.SetMode(&saved_mode); 448 } 449 450 // Effectivelly set/reset full screen mode. If we are already in 451 // full screen mode, we reset back to windowed mode first so the 452 // window can resize when going fullscreen. 453 // if (fullscreen) 454 // printf("Going fullscreen\n"); 455 // else 456 // printf("Going windowed\n"); 457 SDL_Win->SetFullScreen(fullscreen); 458 459 // Calculate offsets for centering the window (in window mode) and for 460 // dentering the bitmap (in full screen mode). 461 BRect bounds = bscreen.Frame(); 462 bounds.PrintToStream(); 463 int32 cx = (bounds.IntegerWidth() - width)/2; 464 int32 cy = (bounds.IntegerHeight() - height)/2; 465 466 // printf ("cx = %d, cy = %d\n", cx, cy); 467 if (!SDL_Win->IsFullScreen()) { 468 // printf("Doing not fullscreen stuff.\n"); 469 // We are not in full screen mode, so we want to change the window 470 // size to match the resolution in SDL. 471 SDL_Win->ResizeTo(width, height); 472 473 // And also center the window and reset the drawing offset. 474 SDL_Win->MoveTo(cx, cy); 475 SDL_Win->SetXYOffset(0, 0); 476 } else { 477 // printf("Doing fullscreen stuff."); 478 // Center the bitmap whenever we are in full screen mode. 479 SDL_Win->SetXYOffset(cx, cy); 480 } 481 482 // Set relevant internal SDL screen flags. 483 if (SDL_Win->IsFullScreen()) { 484 screen->flags |= SDL_FULLSCREEN; 485 } else { 486 screen->flags &= ~SDL_FULLSCREEN; 487 } 488 489 return(1); 490 } 491 492 static int BE_ToggleFullScreen(_THIS, int fullscreen) 493 { 494 return BE_SetFullScreen(_this, _this->screen, fullscreen); 495 } 496 497 /* FIXME: check return values and cleanup here */ 498 SDL_Surface *BE_SetVideoMode(_THIS, SDL_Surface *current, 499 int width, int height, int bpp, Uint32 flags) 500 { 501 BScreen bscreen; 502 BBitmap *bbitmap; 503 BRect bounds; 504 Uint32 gl_flags = 0; 505 506 /* Only RGB works on r5 currently */ 507 gl_flags = BGL_RGB; 508 if (_this->gl_config.double_buffer) 509 gl_flags |= BGL_DOUBLE; 510 else 511 gl_flags |= BGL_SINGLE; 512 if (_this->gl_config.alpha_size > 0 || bpp == 32) 513 gl_flags |= BGL_ALPHA; 514 if (_this->gl_config.depth_size > 0) 515 gl_flags |= BGL_DEPTH; 516 if (_this->gl_config.stencil_size > 0) 517 gl_flags |= BGL_STENCIL; 518 if (_this->gl_config.accum_red_size > 0 519 || _this->gl_config.accum_green_size > 0 520 || _this->gl_config.accum_blue_size > 0 521 || _this->gl_config.accum_alpha_size > 0) 522 gl_flags |= BGL_ACCUM; 523 524 /* Create the view for this window, using found flags */ 525 if ( SDL_Win->CreateView(flags, gl_flags) < 0 ) { 526 return(NULL); 527 } 528 529 current->flags = 0; /* Clear flags */ 530 current->w = width; 531 current->h = height; 532 SDL_Win->SetType(B_TITLED_WINDOW); 533 if ( flags & SDL_NOFRAME ) { 534 current->flags |= SDL_NOFRAME; 535 SDL_Win->SetLook(B_NO_BORDER_WINDOW_LOOK); 536 } else { 537 if ( (flags & SDL_RESIZABLE) && !(flags & SDL_OPENGL) ) { 538 current->flags |= SDL_RESIZABLE; 539 /* We don't want opaque resizing (TM). :-) */ 540 SDL_Win->SetFlags(B_OUTLINE_RESIZE); 541 } else { 542 SDL_Win->SetFlags(B_NOT_RESIZABLE|B_NOT_ZOOMABLE); 543 } 544 } 545 546 if ( flags & SDL_OPENGL ) { 547 current->flags |= SDL_OPENGL; 548 current->pitch = 0; 549 current->pixels = NULL; 550 _this->UpdateRects = NULL; 551 } else { 552 /* Create the BBitmap framebuffer */ 553 bounds.top = 0; bounds.left = 0; 554 bounds.right = width-1; 555 bounds.bottom = height-1; 556 bbitmap = new BBitmap(bounds, bscreen.ColorSpace()); 557 if ( ! bbitmap->IsValid() ) { 558 SDL_SetError("Couldn't create screen bitmap"); 559 delete bbitmap; 560 return(NULL); 561 } 562 current->pitch = bbitmap->BytesPerRow(); 563 current->pixels = (void *)bbitmap->Bits(); 564 SDL_Win->SetBitmap(bbitmap); 565 _this->UpdateRects = BE_NormalUpdate; 566 } 567 568 /* Set the correct fullscreen mode */ 569 BE_SetFullScreen(_this, current, flags & SDL_FULLSCREEN ? 1 : 0); 570 571 /* We're done */ 572 return(current); 573 } 574 575 /* Update the current mouse state and position */ 576 void BE_UpdateMouse(_THIS) 577 { 578 BPoint point; 579 uint32 buttons; 580 581 if ( SDL_Win->Lock() ) { 582 /* Get new input state, if still active */ 583 if ( SDL_Win->IsActive() ) { 584 (SDL_Win->View())->GetMouse(&point, &buttons, true); 585 } else { 586 point.x = -1; 587 point.y = -1; 588 } 589 SDL_Win->Unlock(); 590 591 if ( (point.x >= 0) && (point.x < SDL_VideoSurface->w) && 592 (point.y >= 0) && (point.y < SDL_VideoSurface->h) ) { 593 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); 594 SDL_PrivateMouseMotion(0, 0, 595 (Sint16)point.x, (Sint16)point.y); 596 } else { 597 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); 598 } 599 } 600 } 601 602 /* We don't actually allow hardware surfaces other than the main one */ 603 static int BE_AllocHWSurface(_THIS, SDL_Surface *surface) 604 { 605 return(-1); 606 } 607 static void BE_FreeHWSurface(_THIS, SDL_Surface *surface) 608 { 609 return; 610 } 611 static int BE_LockHWSurface(_THIS, SDL_Surface *surface) 612 { 613 return(0); 614 } 615 static void BE_UnlockHWSurface(_THIS, SDL_Surface *surface) 616 { 617 return; 618 } 619 620 static void BE_NormalUpdate(_THIS, int numrects, SDL_Rect *rects) 621 { 622 if ( SDL_Win->BeginDraw() ) { 623 int i; 624 625 for ( i=0; i<numrects; ++i ) { 626 BRect rect; 627 628 rect.top = rects[i].y; 629 rect.left = rects[i].x; 630 rect.bottom = rect.top+rects[i].h-1; 631 rect.right = rect.left+rects[i].w-1; 632 SDL_Win->DrawAsync(rect); 633 } 634 SDL_Win->EndDraw(); 635 } 636 } 637 638 #if SDL_VIDEO_OPENGL 639 /* Passing a NULL path means load pointers from the application */ 640 int BE_GL_LoadLibrary(_THIS, const char *path) 641 { 642 if (path == NULL) { 643 if (_this->gl_config.dll_handle == NULL) { 644 image_info info; 645 int32 cookie = 0; 646 while (get_next_image_info(0,&cookie,&info) == B_OK) { 647 void *location = NULL; 648 #ifdef __HAIKU__ 649 if (get_image_symbol(info.id,"glBegin",B_SYMBOL_TYPE_ANY,&location) == B_OK) { // This is how it actually works in Haiku 650 #else 651 if (get_image_symbol((image_id)cookie,"glBegin",B_SYMBOL_TYPE_ANY,&location) == B_OK) { // I don't know if that *did* work in BeOS 652 #endif 653 _this->gl_config.dll_handle = (void*)info.id; 654 _this->gl_config.driver_loaded = 1; 655 SDL_strlcpy(_this->gl_config.driver_path, "libGL.so", SDL_arraysize(_this->gl_config.driver_path)); 656 } 657 } 658 } 659 } else { 660 /* 661 FIXME None of BeOS libGL.so implementations have exported functions 662 to load BGLView, which should be reloaded from new lib. 663 So for now just "load" linked libGL.so :( 664 */ 665 if (_this->gl_config.dll_handle == NULL) { 666 return BE_GL_LoadLibrary(_this, NULL); 667 } 668 669 /* Unload old first */ 670 /*if (_this->gl_config.dll_handle != NULL) {*/ 671 /* Do not try to unload application itself (if LoadLibrary was called before with NULL ;) */ 672 /* image_info info; 673 if (get_image_info((image_id)_this->gl_config.dll_handle, &info) == B_OK) { 674 if (info.type != B_APP_IMAGE) { 675 unload_add_on((image_id)_this->gl_config.dll_handle); 676 } 677 } 678 679 } 680 681 if ((_this->gl_config.dll_handle = (void*)load_add_on(path)) != (void*)B_ERROR) { 682 _this->gl_config.driver_loaded = 1; 683 SDL_strlcpy(_this->gl_config.driver_path, path, SDL_arraysize(_this->gl_config.driver_path)); 684 }*/ 685 } 686 687 if (_this->gl_config.dll_handle != NULL) { 688 return 0; 689 } else { 690 _this->gl_config.dll_handle = NULL; 691 _this->gl_config.driver_loaded = 0; 692 *_this->gl_config.driver_path = '\0'; 693 return -1; 694 } 695 } 696 697 void* BE_GL_GetProcAddress(_THIS, const char *proc) 698 { 699 if (_this->gl_config.dll_handle != NULL) { 700 void *location = NULL; 701 status_t err; 702 if ((err = get_image_symbol((image_id)_this->gl_config.dll_handle, proc, B_SYMBOL_TYPE_ANY, &location)) == B_OK) { 703 return location; 704 } else { 705 SDL_SetError("Couldn't find OpenGL symbol"); 706 return NULL; 707 } 708 } else { 709 SDL_SetError("OpenGL library not loaded"); 710 return NULL; 711 } 712 } 713 714 int BE_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value) 715 { 716 /* 717 FIXME? Right now BE_GL_GetAttribute shouldn't be called between glBegin() and glEnd() - it doesn't use "cached" values 718 */ 719 switch (attrib) 720 { 721 case SDL_GL_RED_SIZE: 722 glGetIntegerv(GL_RED_BITS, (GLint*)value); 723 break; 724 case SDL_GL_GREEN_SIZE: 725 glGetIntegerv(GL_GREEN_BITS, (GLint*)value); 726 break; 727 case SDL_GL_BLUE_SIZE: 728 glGetIntegerv(GL_BLUE_BITS, (GLint*)value); 729 break; 730 case SDL_GL_ALPHA_SIZE: 731 glGetIntegerv(GL_ALPHA_BITS, (GLint*)value); 732 break; 733 case SDL_GL_DOUBLEBUFFER: 734 glGetBooleanv(GL_DOUBLEBUFFER, (GLboolean*)value); 735 break; 736 case SDL_GL_BUFFER_SIZE: 737 int v; 738 glGetIntegerv(GL_RED_BITS, (GLint*)&v); 739 *value = v; 740 glGetIntegerv(GL_GREEN_BITS, (GLint*)&v); 741 *value += v; 742 glGetIntegerv(GL_BLUE_BITS, (GLint*)&v); 743 *value += v; 744 glGetIntegerv(GL_ALPHA_BITS, (GLint*)&v); 745 *value += v; 746 break; 747 case SDL_GL_DEPTH_SIZE: 748 glGetIntegerv(GL_DEPTH_BITS, (GLint*)value); /* Mesa creates 16 only? r5 always 32 */ 749 break; 750 case SDL_GL_STENCIL_SIZE: 751 glGetIntegerv(GL_STENCIL_BITS, (GLint*)value); 752 break; 753 case SDL_GL_ACCUM_RED_SIZE: 754 glGetIntegerv(GL_ACCUM_RED_BITS, (GLint*)value); 755 break; 756 case SDL_GL_ACCUM_GREEN_SIZE: 757 glGetIntegerv(GL_ACCUM_GREEN_BITS, (GLint*)value); 758 break; 759 case SDL_GL_ACCUM_BLUE_SIZE: 760 glGetIntegerv(GL_ACCUM_BLUE_BITS, (GLint*)value); 761 break; 762 case SDL_GL_ACCUM_ALPHA_SIZE: 763 glGetIntegerv(GL_ACCUM_ALPHA_BITS, (GLint*)value); 764 break; 765 case SDL_GL_STEREO: 766 case SDL_GL_MULTISAMPLEBUFFERS: 767 case SDL_GL_MULTISAMPLESAMPLES: 768 default: 769 *value=0; 770 return(-1); 771 } 772 return 0; 773 } 774 775 int BE_GL_MakeCurrent(_THIS) 776 { 777 /* FIXME: should we glview->unlock and then glview->lock()? */ 778 return 0; 779 } 780 781 void BE_GL_SwapBuffers(_THIS) 782 { 783 SDL_Win->SwapBuffers(); 784 } 785 #endif 786 787 /* Is the system palette settable? */ 788 int BE_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) 789 { 790 int i; 791 SDL_Palette *palette; 792 const color_map *cmap = BScreen().ColorMap(); 793 794 /* Get the screen colormap */ 795 palette = _this->screen->format->palette; 796 for ( i=0; i<256; ++i ) { 797 palette->colors[i].r = cmap->color_list[i].red; 798 palette->colors[i].g = cmap->color_list[i].green; 799 palette->colors[i].b = cmap->color_list[i].blue; 800 } 801 return(0); 802 } 803 804 void BE_VideoQuit(_THIS) 805 { 806 int i, j; 807 808 SDL_Win->Quit(); 809 SDL_Win = NULL; 810 811 if ( SDL_BlankCursor != NULL ) { 812 BE_FreeWMCursor(_this, SDL_BlankCursor); 813 SDL_BlankCursor = NULL; 814 } 815 for ( i=0; i<NUM_MODELISTS; ++i ) { 816 if ( SDL_modelist[i] ) { 817 for ( j=0; SDL_modelist[i][j]; ++j ) { 818 SDL_free(SDL_modelist[i][j]); 819 } 820 SDL_free(SDL_modelist[i]); 821 SDL_modelist[i] = NULL; 822 } 823 } 824 /* Restore the original video mode */ 825 if ( _this->screen ) { 826 if ( (_this->screen->flags&SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 827 BScreen bscreen; 828 bscreen.SetMode(&saved_mode); 829 } 830 _this->screen->pixels = NULL; 831 } 832 833 #if SDL_VIDEO_OPENGL 834 if (_this->gl_config.dll_handle != NULL) 835 unload_add_on((image_id)_this->gl_config.dll_handle); 836 #endif 837 838 SDL_QuitBeApp(); 839 } 840 841 }; /* Extern C */ 842
