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 /* 25 Written by Darrell Walisser <dwaliss1 (at) purdue.edu> 26 27 Implementation notes ---------------------------------------------------------------------- 28 29 A bit on GWorlds in VRAM from technote 1182: 30 31 There are two important things to note about GWorld's allocated in 32 VRAM. First, the base address retrieved through GetPixBaseAddr or 33 read directly from the PixMap structure can become invalid anytime 34 memory is allocated in VRAM. This can occur either by explicit 35 allocations, such as calls to NewGWorld, or by implicit ones, such as 36 those associated with the internal texture allocation of OpenGL. The 37 stored pixel images themselves will still be valid but may have been 38 moved in VRAM, thus rendering any stored base addresses invalid. 39 You should never store an image's base address for longer than is 40 necessary and especially never across calls to NewGWorld or 41 texture-creation routines. 42 43 Secondly, an offscreen pixel image allocated in VRAM can be 44 purged at system task time by the display driver. This means any 45 time your application yields time such by calling WaitNextEvent or 46 SystemTask you can lose your VRAM GWorld contents. While this 47 happens infrequently, usually associated with display resolution or 48 pixel depth changes you must code for this eventuality. This purge 49 can occur whether or not the GWorld is locked or not. A return value 50 of false from LockPixels, a NULL return value from GetPixBaseAddr 51 or NULL in the baseAddr field of the PixMap mean that the pixel 52 image has been purged. To reallocate it you can either call 53 UpdateGWorld or Dispose your current GWorld through 54 DisposeGWorld and reallocate it via NewGWorld. Either way you must 55 then rebuild the pixel image. 56 57 ------------------------------------------------------------------------------------ 58 59 Currently, I don't account for (1). In my testing, NewGWorld never invalidated 60 other existing GWorlds in VRAM. However, I do have protection for (2). 61 Namely, I am using GetOSEvent() instead of WaitNextEvent() so that there are no 62 context switches (the app hogs the CPU). Eventually a book-keeping system should 63 be coded to take care of (1) and (2). 64 65 ------------------------------------------------------------------------------------ 66 67 System requirements (* denotes optional): 68 69 1. DrawSprocket 1.7.3 70 2. *MacOS 9 or later (but *not* Mac OS X) for hardware accelerated blit / fill 71 3. *May also require certain graphics hardware for (2). I trust that all Apple OEM 72 hardware will work. Third party accelerators may work if they have QuickDraw 73 acceleration in the drivers and the drivers have been updated for OS 9. The current 74 Voodoo 3 drivers (1.0b12) do not work. 75 76 Coding suggestions: 77 78 1. Use SDL_UpdateRects ! 79 80 If no QuickDraw acceleration is present, double-buffered surfaces will use a back buffer 81 in System memory. I recommend you use SDL_UpdateRects with double-buffered surfaces 82 for best performance on these cards, since the overhead is nearly zero for VRAM back buffer. 83 84 2. Load most-resident surfaces first. 85 86 If you fill up VRAM or AGP memory, there is no contingency for purging to make room for the next one. 87 Therefore, you should load the surfaces you plan to use the most frequently first. 88 Sooner or later, I will code LRU replacement to help this. 89 90 TODO: 91 Some kind of posterized mode for resolutions < 640x480. 92 Window support / fullscreen toggle. 93 Figure out how much VRAM is available. Put in video->info->video_mem. 94 Track VRAM usage. 95 96 BUGS: 97 I can't create a hardware surface the same size as the screen?! How to fix? 98 99 100 101 COMPILE OPTIONS: 102 103 DSP_TRY_CC_AND_AA - Define if you want to try HWA color-key and alpha blitters 104 HW color-key blitting gives substantial improvements, 105 but hw alpha is neck-and-neck with SDL's soft bitter. 106 107 DSP_NO_SYNC_VBL - Define for HWA double-buffered surfaces: don't sync 108 pseudo-flip to monitor redraw. 109 110 DSP_NO_SYNC_OPENGL - Define for OpenGL surfaces: don't sync buffer swap. Synching buffer 111 swap may result in reduced performance, but can eliminate some 112 tearing artifacts. 113 CHANGELOG: 114 09/17/00 Lots of little tweaks. Build modelist in reverse order so largest contexts 115 list first. Compared various methods with ROM methods and fixed rez switch 116 crashing bug in GL Tron. (Woohoo!) 117 */ 118 119 #define DSP_TRY_CC_AND_AA 120 121 /* #define DSP_NO_SYNC_VBL */ 122 123 #define DSP_NO_SYNC_OPENGL 124 125 126 #if defined(__APPLE__) && defined(__MACH__) 127 #include <Carbon/Carbon.h> 128 #include <DrawSprocket/DrawSprocket.h> 129 #elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335) 130 #include <Carbon.h> 131 #include <DrawSprocket.h> 132 #else 133 #include <LowMem.h> 134 #include <Gestalt.h> 135 #include <Devices.h> 136 #include <DiskInit.h> 137 #include <QDOffscreen.h> 138 #include <DrawSprocket.h> 139 #endif 140 141 #include "SDL_video.h" 142 #include "SDL_syswm.h" 143 #include "../SDL_sysvideo.h" 144 #include "../SDL_blit.h" 145 #include "../SDL_pixels_c.h" 146 #include "SDL_dspvideo.h" 147 #include "../maccommon/SDL_macgl_c.h" 148 #include "../maccommon/SDL_macwm_c.h" 149 #include "../maccommon/SDL_macmouse_c.h" 150 #include "../maccommon/SDL_macevents_c.h" 151 152 /* Initialization/Query functions */ 153 static int DSp_VideoInit(_THIS, SDL_PixelFormat *vformat); 154 static SDL_Rect **DSp_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); 155 static SDL_Surface *DSp_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); 156 static int DSp_SetColors(_THIS, int firstcolor, int ncolors, 157 SDL_Color *colors); 158 static int DSp_CreatePalette(_THIS); 159 static int DSp_DestroyPalette(_THIS); 160 static void DSp_VideoQuit(_THIS); 161 162 static int DSp_GetMainDevice (_THIS, GDHandle *device); 163 static void DSp_IsHWAvailable (_THIS, SDL_PixelFormat *vformat); 164 static void DSp_DSpUpdate(_THIS, int numrects, SDL_Rect *sdl_rects); 165 static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *sdl_rects); 166 167 /* Hardware surface functions */ 168 static int DSp_SetHWAlpha(_THIS, SDL_Surface *surface, UInt8 alpha); 169 static int DSp_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key); 170 static int DSp_NewHWSurface(_THIS, CGrafPtr *port, int depth, int width, int height); 171 static int DSp_AllocHWSurface(_THIS, SDL_Surface *surface); 172 static int DSp_LockHWSurface(_THIS, SDL_Surface *surface); 173 static void DSp_UnlockHWSurface(_THIS, SDL_Surface *surface); 174 static void DSp_FreeHWSurface(_THIS, SDL_Surface *surface); 175 static int DSp_FlipHWSurface(_THIS, SDL_Surface *surface); 176 static int DSp_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dest); 177 static int DSp_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, 178 SDL_Surface *dst, SDL_Rect *dstrect); 179 static int DSp_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color); 180 181 #if SDL_VIDEO_OPENGL 182 static void DSp_GL_SwapBuffers (_THIS); 183 #endif 184 185 #if ! TARGET_API_MAC_CARBON 186 187 #define GetPortPixRowBytes(x) ( (*(x->portPixMap))->rowBytes ) 188 #define GetGDevPixMap(x) ((**(x)).gdPMap) 189 #define GetPortPixMap(x) ((*(x)).portPixMap) 190 191 #define GetPixDepth(y) ((**(y)).pixelSize) 192 //#define GetPixRowBytes(y) ((**(y)).rowBytes) 193 //#define GetPixBaseAddr(y) ((**(y)).baseAddr) 194 #define GetPixCTab(y) ((**(y)).pmTable) 195 #define GetPortBitMapForCopyBits(x) (&(((GrafPtr)(x))->portBits)) 196 197 #else 198 #define GetPortPixRowBytes(x) (GetPixRowBytes(GetPortPixMap(x)) ) 199 #define GetGDevPixMap(x) ((**(x)).gdPMap) 200 201 #endif 202 203 typedef struct private_hwdata { 204 205 GWorldPtr offscreen; // offscreen gworld in VRAM or AGP 206 207 #ifdef DSP_TRY_CC_AND_AA 208 GWorldPtr mask; // transparent mask 209 RGBColor alpha; // alpha color 210 RGBColor trans; // transparent color 211 #endif 212 213 } private_hwdata; 214 215 typedef private_hwdata private_swdata ; /* have same fields */ 216 217 /* Macintosh toolbox driver bootstrap functions */ 218 219 static int DSp_Available(void) 220 { 221 /* Check for DrawSprocket */ 222 #if ! TARGET_API_MAC_OSX 223 /* This check is only meaningful if you weak-link DrawSprocketLib */ 224 return ((Ptr)DSpStartup != (Ptr)kUnresolvedCFragSymbolAddress); 225 #else 226 return 1; // DrawSprocket.framework doesn't have it all, but it's there 227 #endif 228 } 229 230 static void DSp_DeleteDevice(SDL_VideoDevice *device) 231 { 232 /* -dw- taking no chances with null pointers */ 233 if (device) { 234 235 if (device->hidden) { 236 237 if (device->hidden->dspinfo) 238 SDL_free(device->hidden->dspinfo); 239 240 SDL_free(device->hidden); 241 } 242 SDL_free(device); 243 } 244 } 245 246 static SDL_VideoDevice *DSp_CreateDevice(int devindex) 247 { 248 SDL_VideoDevice *device; 249 250 /* Initialize all variables that we clean on shutdown */ 251 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); 252 if ( device ) { 253 SDL_memset(device, 0, sizeof (*device)); 254 device->hidden = (struct SDL_PrivateVideoData *) 255 SDL_malloc((sizeof *device->hidden)); 256 if (device->hidden) 257 SDL_memset(device->hidden, 0, sizeof ( *(device->hidden) ) ); 258 } 259 if ( (device == NULL) || (device->hidden == NULL) ) { 260 SDL_OutOfMemory(); 261 262 if ( device ) { 263 264 if (device->hidden) 265 SDL_free(device->hidden); 266 267 SDL_free(device); 268 } 269 270 return(NULL); 271 } 272 273 /* Allocate DrawSprocket information */ 274 device->hidden->dspinfo = (struct DSpInfo *)SDL_malloc( 275 (sizeof *device->hidden->dspinfo)); 276 if ( device->hidden->dspinfo == NULL ) { 277 SDL_OutOfMemory(); 278 SDL_free(device->hidden); 279 SDL_free(device); 280 return(0); 281 } 282 SDL_memset(device->hidden->dspinfo, 0, (sizeof *device->hidden->dspinfo)); 283 284 /* Set the function pointers */ 285 device->VideoInit = DSp_VideoInit; 286 device->ListModes = DSp_ListModes; 287 device->SetVideoMode = DSp_SetVideoMode; 288 device->SetColors = DSp_SetColors; 289 device->UpdateRects = NULL; 290 device->VideoQuit = DSp_VideoQuit; 291 device->AllocHWSurface = DSp_AllocHWSurface; 292 device->CheckHWBlit = NULL; 293 device->FillHWRect = NULL; 294 device->SetHWColorKey = NULL; 295 device->SetHWAlpha = NULL; 296 device->LockHWSurface = DSp_LockHWSurface; 297 device->UnlockHWSurface = DSp_UnlockHWSurface; 298 device->FlipHWSurface = DSp_FlipHWSurface; 299 device->FreeHWSurface = DSp_FreeHWSurface; 300 #if SDL_MACCLASSIC_GAMMA_SUPPORT 301 device->SetGammaRamp = Mac_SetGammaRamp; 302 device->GetGammaRamp = Mac_GetGammaRamp; 303 #endif 304 #if SDL_VIDEO_OPENGL 305 device->GL_MakeCurrent = Mac_GL_MakeCurrent; 306 device->GL_SwapBuffers = DSp_GL_SwapBuffers; 307 device->GL_LoadLibrary = Mac_GL_LoadLibrary; 308 device->GL_GetProcAddress = Mac_GL_GetProcAddress; 309 #endif 310 device->SetCaption = NULL; 311 device->SetIcon = NULL; 312 device->IconifyWindow = NULL; 313 device->GrabInput = NULL; 314 device->GetWMInfo = NULL; 315 device->FreeWMCursor = Mac_FreeWMCursor; 316 device->CreateWMCursor = Mac_CreateWMCursor; 317 device->ShowWMCursor = Mac_ShowWMCursor; 318 device->WarpWMCursor = Mac_WarpWMCursor; 319 device->InitOSKeymap = Mac_InitOSKeymap; 320 device->PumpEvents = Mac_PumpEvents; 321 322 device->GrabInput = NULL; 323 device->CheckMouseMode = NULL; 324 325 device->free = DSp_DeleteDevice; 326 327 return device; 328 } 329 330 VideoBootStrap DSp_bootstrap = { 331 "DSp", "MacOS DrawSprocket", 332 DSp_Available, DSp_CreateDevice 333 }; 334 335 /* Use DSp/Display Manager to build mode list for given screen */ 336 static SDL_Rect** DSp_BuildModeList (const GDHandle gDevice, int *displayWidth, int *displayHeight) 337 { 338 DSpContextAttributes attributes; 339 DSpContextReference context; 340 DisplayIDType displayID; 341 SDL_Rect temp_list [16]; 342 SDL_Rect **mode_list; 343 int width, height, i, j; 344 345 #if TARGET_API_MAC_OSX 346 347 displayID = 0; 348 349 #else 350 /* Ask Display Manager for integer id of screen device */ 351 if ( DMGetDisplayIDByGDevice (gDevice, &displayID, SDL_TRUE) != noErr ) { 352 return NULL; 353 } 354 #endif 355 /* Get the first possible DSp context on this device */ 356 if ( DSpGetFirstContext (displayID, &context) != noErr ) { 357 return NULL; 358 } 359 360 if ( DSpContext_GetAttributes (context, &attributes) != noErr ) 361 return NULL; 362 363 *displayWidth = attributes.displayWidth; 364 *displayHeight = attributes.displayHeight; 365 366 for ( i = 0; i < SDL_arraysize(temp_list); i++ ) { 367 width = attributes.displayWidth; 368 height = attributes.displayHeight; 369 370 temp_list [i].x = 0 | attributes.displayBestDepth; 371 temp_list [i].y = 0; 372 temp_list [i].w = width; 373 temp_list [i].h = height; 374 375 /* DSp will report many different contexts with the same width and height. */ 376 /* They will differ in bit depth and refresh rate. */ 377 /* We will ignore them until we reach one with a different width/height */ 378 /* When there are no more contexts to look at, we will quit building the list*/ 379 while ( width == attributes.displayWidth && height == attributes.displayHeight ) { 380 381 OSStatus err = DSpGetNextContext (context, &context); 382 if (err != noErr) 383 if (err == kDSpContextNotFoundErr) 384 goto done; 385 else 386 return NULL; 387 388 if ( DSpContext_GetAttributes (context, &attributes) != noErr ) 389 return NULL; 390 391 temp_list [i].x |= attributes.displayBestDepth; 392 } 393 } 394 done: 395 i++; /* i was not incremented before kicking out of the loop */ 396 397 mode_list = (SDL_Rect**) SDL_malloc (sizeof (SDL_Rect*) * (i+1)); 398 if (mode_list) { 399 400 /* -dw- new stuff: build in reverse order so largest sizes list first */ 401 for (j = i-1; j >= 0; j--) { 402 mode_list [j] = (SDL_Rect*) SDL_malloc (sizeof (SDL_Rect)); 403 if (mode_list [j]) 404 SDL_memcpy (mode_list [j], &(temp_list [j]), sizeof (SDL_Rect)); 405 else { 406 SDL_OutOfMemory (); 407 return NULL; 408 } 409 } 410 mode_list [i] = NULL; /* append null to the end */ 411 } 412 else { 413 SDL_OutOfMemory (); 414 return NULL; 415 } 416 417 return mode_list; 418 } 419 420 static void DSp_IsHWAvailable (_THIS, SDL_PixelFormat *vformat) 421 { 422 /* 423 VRAM GWorlds are only available on OS 9 or later. 424 Even with OS 9, some display drivers won't support it, 425 so we create a test GWorld and check for errors. 426 */ 427 428 long versionSystem; 429 430 dsp_vram_available = SDL_FALSE; 431 dsp_agp_available = SDL_FALSE; 432 433 Gestalt ('sysv', &versionSystem); 434 if (0x00000860 < (versionSystem & 0x0000FFFF)) { 435 436 GWorldPtr offscreen; 437 OSStatus err; 438 Rect bounds; 439 440 SetRect (&bounds, 0, 0, 320, 240); 441 442 #if useDistantHdwrMem && useLocalHdwrMem 443 err = NewGWorld (&offscreen, vformat->BitsPerPixel, &bounds, NULL, SDL_Display, useDistantHdwrMem | noNewDevice); 444 if (err == noErr) { 445 dsp_vram_available = SDL_TRUE; 446 DisposeGWorld (offscreen); 447 } 448 449 err = NewGWorld (&offscreen, vformat->BitsPerPixel, &bounds, NULL, SDL_Display, useLocalHdwrMem | noNewDevice); 450 if (err == noErr) { 451 DisposeGWorld (offscreen); 452 dsp_agp_available = SDL_TRUE; 453 } 454 #endif 455 } 456 } 457 458 static int DSp_GetMainDevice (_THIS, GDHandle *device) 459 { 460 461 #if TARGET_API_MAC_OSX 462 /* DSpUserSelectContext not available on OS X */ 463 *device = GetMainDevice(); 464 return 0; 465 #else 466 467 DSpContextAttributes attrib; 468 DSpContextReference context; 469 DisplayIDType display_id; 470 GDHandle main_device; 471 GDHandle device_list; 472 473 device_list = GetDeviceList (); 474 main_device = GetMainDevice (); 475 476 /* Quick check to avoid slower method when only one display exists */ 477 if ( (**device_list).gdNextGD == NULL ) { 478 *device = main_device; 479 return 0; 480 } 481 482 SDL_memset (&attrib, 0, sizeof (DSpContextAttributes)); 483 484 /* These attributes are hopefully supported on all devices...*/ 485 attrib.displayWidth = 640; 486 attrib.displayHeight = 480; 487 attrib.displayBestDepth = 8; 488 attrib.backBufferBestDepth = 8; 489 attrib.displayDepthMask = kDSpDepthMask_All; 490 attrib.backBufferDepthMask = kDSpDepthMask_All; 491 attrib.colorNeeds = kDSpColorNeeds_Require; 492 attrib.pageCount = 1; 493 494 if (noErr != DMGetDisplayIDByGDevice (main_device, &display_id, SDL_FALSE)) { 495 SDL_SetError ("Display Manager couldn't associate GDevice with a Display ID"); 496 return (-1); 497 } 498 499 /* Put up dialog on main display to select which display to use */ 500 if (noErr != DSpUserSelectContext (&attrib, display_id, NULL, &context)) { 501 SDL_SetError ("DrawSprocket couldn't create a context"); 502 return (-1); 503 } 504 505 if (noErr != DSpContext_GetDisplayID (context, &display_id)) { 506 SDL_SetError ("DrawSprocket couldn't get display ID"); 507 return (-1); 508 } 509 510 if (noErr != DMGetGDeviceByDisplayID (display_id, &main_device, SDL_FALSE)) { 511 SDL_SetError ("Display Manager couldn't associate Display ID with GDevice"); 512 return (-1); 513 } 514 515 *device = main_device; 516 return (0); 517 #endif 518 } 519 520 static int DSp_VideoInit(_THIS, SDL_PixelFormat *vformat) 521 { 522 NumVersion dsp_version = { 0x01, 0x00, 0x00, 0x00 }; 523 524 #if UNIVERSAL_INTERFACES_VERSION > 0x0320 525 dsp_version = DSpGetVersion (); 526 #endif 527 528 if ( (dsp_version.majorRev == 1 && dsp_version.minorAndBugRev < 0x73) || 529 (dsp_version.majorRev < 1) ) { 530 531 /* StandardAlert (kAlertStopAlert, "\pError!", 532 "\pI need DrawSprocket 1.7.3 or later!\n" 533 "You can find a newer version at http://www.apple.com/swupdates.", 534 NULL, NULL); 535 */ 536 SDL_SetError ("DrawSprocket version is too old. Need 1.7.3 or later."); 537 return (-1); 538 } 539 540 if ( DSpStartup () != noErr ) { 541 SDL_SetError ("DrawSprocket couldn't startup"); 542 return(-1); 543 } 544 545 /* Start DSpintosh events */ 546 Mac_InitEvents(this); 547 548 /* Get a handle to the main monitor, or choose one on multiple monitor setups */ 549 if ( DSp_GetMainDevice(this, &SDL_Display) < 0) 550 return (-1); 551 552 /* Determine pixel format */ 553 vformat->BitsPerPixel = GetPixDepth ( (**SDL_Display).gdPMap ); 554 dsp_old_depth = vformat->BitsPerPixel; 555 556 switch (vformat->BitsPerPixel) { 557 case 16: 558 vformat->Rmask = 0x00007c00; 559 vformat->Gmask = 0x000003e0; 560 vformat->Bmask = 0x0000001f; 561 break; 562 default: 563 break; 564 } 565 566 if ( DSp_CreatePalette (this) < 0 ) { 567 SDL_SetError ("Could not create palette"); 568 return (-1); 569 } 570 571 /* Get a list of available fullscreen modes */ 572 SDL_modelist = DSp_BuildModeList (SDL_Display, 573 &this->info.current_w, &this->info.current_h); 574 if (SDL_modelist == NULL) { 575 SDL_SetError ("DrawSprocket could not build a mode list"); 576 return (-1); 577 } 578 579 /* Check for VRAM and AGP GWorlds for HW Blitting */ 580 DSp_IsHWAvailable (this, vformat); 581 582 this->info.wm_available = 0; 583 584 if (dsp_vram_available || dsp_agp_available) { 585 586 this->info.hw_available = SDL_TRUE; 587 588 this->CheckHWBlit = DSp_CheckHWBlit; 589 this->info.blit_hw = SDL_TRUE; 590 591 this->FillHWRect = DSp_FillHWRect; 592 this->info.blit_fill = SDL_TRUE; 593 594 #ifdef DSP_TRY_CC_AND_AA 595 this->SetHWColorKey = DSp_SetHWColorKey; 596 this->info.blit_hw_CC = SDL_TRUE; 597 598 this->SetHWAlpha = DSp_SetHWAlpha; 599 this->info.blit_hw_A = SDL_TRUE; 600 #endif 601 602 } 603 604 return(0); 605 } 606 607 static SDL_Rect **DSp_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) 608 { 609 static SDL_Rect *dsp_modes[16]; 610 int i = 0, j = 0; 611 612 if ( format->BitsPerPixel == 0 ) 613 return ( (SDL_Rect**) NULL ); 614 615 while (SDL_modelist[i] != NULL) { 616 617 if (SDL_modelist[i]->x & format->BitsPerPixel) { 618 dsp_modes[j] = SDL_modelist[i]; 619 j++; 620 } 621 i++; 622 } 623 624 dsp_modes[j] = NULL; 625 626 return dsp_modes; 627 } 628 629 /* Various screen update functions available */ 630 static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); 631 632 #if ! TARGET_API_MAC_OSX 633 634 static volatile unsigned int retrace_count = 0; /* -dw- need volatile because it updates asychronously */ 635 636 Boolean DSp_VBLProc ( DSpContextReference context, void *ref_con ) 637 { 638 retrace_count++; 639 640 return 1; /* Darrell, is this right? */ 641 } 642 643 static void DSp_SetHWError (OSStatus err, int is_agp) 644 { 645 char message[1024]; 646 const char *fmt, *mem; 647 648 if ( is_agp ) { 649 mem = "AGP Memory"; 650 } else { 651 mem = "VRAM"; 652 } 653 switch(err) { 654 case memFullErr: 655 fmt = "Hardware surface possible but not enough %s available"; 656 break; 657 case cDepthErr: 658 fmt = "Hardware surface possible but invalid color depth"; 659 break; 660 default: 661 fmt = "Hardware surface could not be allocated in %s - unknown error"; 662 break; 663 } 664 SDL_snprintf(message, SDL_arraysize(message), fmt, mem); 665 SDL_SetError(message); 666 } 667 #endif // TARGET_API_MAC_OSX 668 669 /* put up a dialog to verify display change */ 670 static int DSp_ConfirmSwitch () { 671 672 /* resource id's for dialog */ 673 const int rDialog = 1002; 674 const int bCancel = 1; 675 const int bOK = 2; 676 677 DialogPtr dialog; 678 OSStatus err; 679 SInt32 response; 680 DialogItemIndex item = 0; 681 GrafPtr savePort; 682 683 GetPort (&savePort); 684 685 dialog = GetNewDialog (rDialog, NULL, (WindowPtr) -1); 686 if (dialog == NULL) 687 return (0); 688 689 #if TARGET_API_MAC_CARBON 690 SetPort (GetDialogPort(dialog)); 691 #else 692 SetPort ((WindowPtr) dialog); 693 #endif 694 695 SetDialogDefaultItem (dialog, bCancel); 696 SetDialogCancelItem (dialog, bCancel); 697 698 SetEventMask (everyEvent); 699 FlushEvents (everyEvent, 0); 700 701 /* On MacOS 8.5 or later, we can make the dialog go away after 15 seconds */ 702 /* This is good since it's possible user can't even see the dialog! */ 703 /* Requires linking to DialogsLib */ 704 err = Gestalt(gestaltSystemVersion,&response); 705 if (err == noErr && response >= 0x00000850) { 706 SetDialogTimeout(dialog, bCancel, 15); 707 } 708 709 do { 710 711 ModalDialog ( NULL, &item ); 712 713 } while ( item != bCancel && item != bOK && err != noErr); 714 715 716 DisposeDialog (dialog); 717 SetPort (savePort); 718 719 SetEventMask(everyEvent - autoKeyMask); 720 FlushEvents(everyEvent, 0); 721 722 return (item - 1); 723 } 724 725 static void DSp_UnsetVideoMode(_THIS, SDL_Surface *current) 726 { 727 728 729 if ( current->flags & SDL_OPENGL ) { 730 Mac_GL_Quit (this); 731 } 732 733 if (dsp_context != NULL) { 734 735 GWorldPtr front; 736 DSpContext_GetFrontBuffer (dsp_context, &front); 737 738 if (front != dsp_back_buffer) 739 DisposeGWorld (dsp_back_buffer); 740 741 if (current->hwdata) 742 SDL_free(current->hwdata); 743 744 DSpContext_SetState (dsp_context, kDSpContextState_Inactive ); 745 DSpContext_Release (dsp_context); 746 747 dsp_context = NULL; 748 } 749 750 if (SDL_Window != NULL) { 751 DisposeWindow (SDL_Window); 752 SDL_Window = NULL; 753 } 754 755 current->pixels = NULL; 756 current->flags = 0; 757 } 758 759 static SDL_Surface *DSp_SetVideoMode(_THIS, 760 SDL_Surface *current, int width, int height, int bpp, Uint32 flags) 761 { 762 763 #if !TARGET_API_MAC_OSX 764 DisplayIDType display_id; 765 Fixed freq; 766 #endif 767 DSpContextAttributes attrib; 768 OSStatus err; 769 UInt32 rmask = 0, gmask = 0, bmask = 0; 770 771 int page_count; 772 int double_buf; 773 int hw_surface; 774 int use_dsp_back_buffer; 775 776 DSp_UnsetVideoMode (this, current); 777 778 if (bpp != dsp_old_depth) 779 DSp_DestroyPalette (this); 780 781 double_buf = (flags & SDL_DOUBLEBUF) != 0; 782 hw_surface = (flags & SDL_HWSURFACE) != 0; 783 use_dsp_back_buffer = !dsp_vram_available || !hw_surface ; 784 785 current->flags |= SDL_FULLSCREEN; 786 787 rebuild: 788 789 if ( double_buf && use_dsp_back_buffer ) { 790 page_count = 2; 791 } else { 792 page_count = 1; 793 } 794 795 SDL_memset (&attrib, 0, sizeof (DSpContextAttributes)); 796 attrib.displayWidth = width; 797 attrib.displayHeight = height; 798 attrib.displayBestDepth = bpp; 799 attrib.backBufferBestDepth = bpp; 800 attrib.displayDepthMask = kDSpDepthMask_All; 801 attrib.backBufferDepthMask = kDSpDepthMask_All; 802 attrib.colorNeeds = kDSpColorNeeds_Require; 803 attrib.colorTable = 0; 804 attrib.pageCount = page_count; 805 #if TARGET_API_MAC_OSX || UNIVERSAL_INTERFACES_VERSION == 0x0320 806 807 if ( DSpFindBestContext (&attrib, &dsp_context) != noErr ) { 808 SDL_SetError ("DrawSprocket couldn't find a context"); 809 return NULL; 810 } 811 812 #else 813 if ( noErr != DMGetDisplayIDByGDevice (SDL_Display, &display_id, SDL_FALSE) ) { 814 SDL_SetError ("Display Manager couldn't associate GDevice with display_id"); 815 return NULL; 816 } 817 if ( DSpFindBestContextOnDisplayID(&attrib, &dsp_context, display_id) != noErr ) { 818 SDL_SetError ("DrawSprocket couldn't find a suitable context on given display"); 819 return NULL; 820 } 821 822 #endif 823 if ( DSpContext_Reserve (dsp_context, &attrib) != noErr ) { 824 SDL_SetError ("DrawSprocket couldn't get the needed resources to build the display"); 825 return NULL; 826 } 827 828 if ( (err = DSpContext_SetState (dsp_context, kDSpContextState_Active)) != noErr ) { 829 830 if (err == kDSpConfirmSwitchWarning) { 831 832 if ( ! DSp_ConfirmSwitch () ) { 833 834 DSpContext_Release (dsp_context); 835 dsp_context = NULL; 836 SDL_SetError ("User cancelled display switch"); 837 return NULL; 838 } 839 else 840 /* Have to reactivate context. Why? */ 841 DSpContext_SetState (dsp_context, kDSpContextState_Active); 842 843 } 844 else { 845 SDL_SetError ("DrawSprocket couldn't activate the context"); 846 return NULL; 847 } 848 } 849 850 851 if (bpp != dsp_old_depth) { 852 853 DSp_CreatePalette (this); 854 855 /* update format if display depth changed */ 856 if (bpp == 16) { 857 858 rmask = 0x00007c00; 859 gmask = 0x000003e0; 860 bmask = 0x0000001f; 861 } 862 if ( ! SDL_ReallocFormat (current, bpp, rmask, gmask, bmask, 0 ) ) { 863 864 SDL_SetError ("Could not reallocate video format."); 865 return(NULL); 866 } 867 } 868 869 if (!double_buf) { 870 871 /* single-buffer context */ 872 DSpContext_GetFrontBuffer (dsp_context, &dsp_back_buffer); 873 874 current->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata)); 875 if (current ->hwdata == NULL) { 876 SDL_OutOfMemory (); 877 return NULL; 878 } 879 current->hwdata->offscreen = dsp_back_buffer; 880 current->flags |= SDL_HWSURFACE; 881 this->UpdateRects = DSp_DirectUpdate; 882 } 883 else if ( use_dsp_back_buffer ) { 884 885 DSpContext_GetBackBuffer (dsp_context, kDSpBufferKind_Normal, &dsp_back_buffer); 886 887 current->flags |= SDL_DOUBLEBUF | SDL_SWSURFACE; /* only front buffer is in VRAM */ 888 this->UpdateRects = DSp_DSpUpdate; 889 } 890 else if ( DSp_NewHWSurface(this, &dsp_back_buffer, bpp, width-1, height-1) == 0 ) { 891 892 current->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata)); 893 if (current ->hwdata == NULL) { 894 SDL_OutOfMemory (); 895 return NULL; 896 } 897 898 SDL_memset (current->hwdata, 0, sizeof (private_hwdata)); 899 current->hwdata->offscreen = dsp_back_buffer; 900 current->flags |= SDL_DOUBLEBUF | SDL_HWSURFACE; 901 this->UpdateRects = DSp_DirectUpdate; /* hardware doesn't do update rects, must be page-flipped */ 902 } 903 else { 904 905 DSpContext_Release (dsp_context); 906 use_dsp_back_buffer = SDL_TRUE; 907 goto rebuild; 908 } 909 910 current->pitch = GetPortPixRowBytes(dsp_back_buffer) & 0x3FFF; 911 current->pixels = GetPixBaseAddr(GetPortPixMap(dsp_back_buffer)); 912 913 current->w = width; 914 current->h = height; 915 916 #if ! TARGET_API_MAC_OSX 917 918 if (use_dsp_back_buffer) { 919 920 DSpContext_GetMonitorFrequency (dsp_context, &freq); 921 DSpContext_SetMaxFrameRate (dsp_context, freq >> 16); 922 } 923 924 925 if ( (current->flags & SDL_HWSURFACE) || (current->flags & SDL_OPENGL) ) 926 DSpContext_SetVBLProc (dsp_context, DSp_VBLProc, NULL); 927 #endif 928 929 if (bpp == 8) 930 current->flags |= SDL_HWPALETTE; 931 932 if (flags & SDL_OPENGL) { 933 934 Rect rect; 935 RGBColor rgb = { 0.0, 0.0, 0.0 }; 936 GrafPtr save_port; 937 938 SetRect (&rect, 0, 0, width, height); 939 SDL_Window = NewCWindow(nil, &( (**SDL_Display).gdRect), "\p", SDL_TRUE, plainDBox, (WindowPtr)-1, SDL_FALSE, 0); 940 941 if (SDL_Window == NULL) { 942 943 SDL_SetError ("DSp_SetVideoMode : OpenGL window could not be created."); 944 return NULL; 945 } 946 947 /* Set window color to black to avoid white flash*/ 948 GetPort (&save_port); 949 #if TARGET_API_MAC_CARBON 950 SetPort (GetWindowPort(SDL_Window)); 951 #else 952 SetPort (SDL_Window); 953 #endif 954 RGBForeColor (&rgb); 955 PaintRect (&rect); 956 SetPort (save_port); 957 958 SetPortWindowPort (SDL_Window); 959 SelectWindow (SDL_Window); 960 961 if ( Mac_GL_Init (this) < 0 ) { 962 963 SDL_SetError ("DSp_SetVideoMode : could not create OpenGL context."); 964 return NULL; 965 } 966 967 current->flags |= SDL_OPENGL; 968 } 969 970 return current; 971 } 972 973 #ifdef DSP_TRY_CC_AND_AA 974 975 static int DSp_MakeHWMask (_THIS, SDL_Surface *surface) 976 { 977 GDHandle save_device; 978 CGrafPtr save_port; 979 GWorldPtr temp; 980 RGBColor black = { 0, 0, 0 }; 981 RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF }; 982 Rect rect; 983 984 Uint32 depth = GetPixDepth ( GetGDevPixMap (SDL_Display) ); 985 986 SetRect (&rect, 0, 0, surface->w, surface->h); 987 988 if ( noErr != NewGWorld (&(surface->hwdata->mask), depth, &rect, 0, SDL_Display, 0 ) < 0 ) { 989 990 SDL_OutOfMemory (); 991 return (-1); 992 } 993 994 if ( noErr != NewGWorld (&temp, depth, &rect, 0 , SDL_Display, 0 ) ) { 995 996 SDL_OutOfMemory (); 997 return (-1); 998 } 999 1000 1001 GetGWorld (&save_port, &save_device); 1002 SetGWorld (surface->hwdata->mask, SDL_Display); 1003 1004 RGBForeColor (&white); 1005 PaintRect (&rect); 1006 1007 RGBBackColor (&(surface->hwdata->trans)); 1008 1009 CopyBits ( GetPortBitMapForCopyBits(surface->hwdata->offscreen), 1010 GetPortBitMapForCopyBits(surface->hwdata->mask), 1011 &rect, &rect, transparent, NULL ); 1012 1013 SetGWorld (surface->hwdata->mask, SDL_Display); 1014 SetGWorld (save_port, save_device); 1015 return (0); 1016 } 1017 1018 static int DSp_SetHWAlpha(_THIS, SDL_Surface *surface, UInt8 alpha) 1019 { 1020 surface->hwdata->alpha.red = (alpha / 255.0) * 65535; 1021 surface->hwdata->alpha.blue = (alpha / 255.0) * 65535; 1022 surface->hwdata->alpha.green = (alpha / 255.0) * 65535; 1023 1024 surface->flags |= SDL_SRCALPHA; 1025 1026 if (surface->flags & SDL_SRCCOLORKEY) { 1027 return(DSp_MakeHWMask (this, surface)); 1028 } 1029 return(0); 1030 } 1031 1032 static int DSp_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) 1033 { 1034 CGrafPtr save_port; 1035 GDHandle save_device; 1036 1037 GetGWorld (&save_port, &save_device); 1038 SetGWorld (surface->hwdata->offscreen, NULL); 1039 1040 Index2Color (key, &(surface->hwdata->trans)); 1041 surface->flags |= SDL_SRCCOLORKEY; 1042 1043 SetGWorld (save_port, save_device); 1044 1045 if ( surface->flags & SDL_SRCALPHA ) { 1046 return(DSp_MakeHWMask (this, surface)); 1047 } 1048 return(0); 1049 } 1050 1051 #endif /* DSP_TRY_CC_AND_AA */ 1052 1053 static int DSp_NewHWSurface(_THIS, CGrafPtr *port, int depth, int width, int height) { 1054 1055 OSStatus err; 1056 Rect bounds; 1057 1058 SetRect (&bounds, 0, 0, width, height); 1059 1060 #if useDistantHdwrMem && useLocalHdwrMem 1061 if (dsp_vram_available) { 1062 /* try VRAM */ 1063 err = NewGWorld (port, depth, &bounds, 0 , SDL_Display, useDistantHdwrMem | noNewDevice ); 1064 if (err != noErr) 1065 DSp_SetHWError (err, SDL_FALSE); 1066 else 1067 return (0); 1068 } 1069 1070 if (dsp_agp_available) { 1071 /* try AGP */ 1072 err = NewGWorld (port, depth, &bounds, 0 , SDL_Display, useLocalHdwrMem | noNewDevice ); 1073 1074 if (err != noErr) 1075 DSp_SetHWError (err, SDL_TRUE); 1076 else 1077 return (0); 1078 } 1079 #endif 1080 1081 return (-1); 1082 } 1083 1084 static int DSp_AllocHWSurface(_THIS, SDL_Surface *surface) 1085 { 1086 GWorldPtr temp; 1087 1088 if ( DSp_NewHWSurface (this, &temp, surface->format->BitsPerPixel, surface->w, surface->h) < 0 ) 1089 return (-1); 1090 1091 surface->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata)); 1092 if (surface->hwdata == NULL) { 1093 SDL_OutOfMemory (); 1094 return -1; 1095 } 1096 1097 SDL_memset (surface->hwdata, 0, sizeof(private_hwdata)); 1098 surface->hwdata->offscreen = temp; 1099 surface->pitch = GetPixRowBytes (GetPortPixMap (temp)) & 0x3FFF; 1100 surface->pixels = GetPixBaseAddr (GetPortPixMap (temp)); 1101 surface->flags |= SDL_HWSURFACE; 1102 #ifdef DSP_TRY_CC_AND_AA 1103 surface->flags |= SDL_HWACCEL; 1104 #endif 1105 return 0; 1106 } 1107 1108 static void DSp_FreeHWSurface(_THIS, SDL_Surface *surface) 1109 { 1110 if (surface->hwdata->offscreen != NULL) 1111 DisposeGWorld (surface->hwdata->offscreen); 1112 SDL_free(surface->hwdata); 1113 1114 surface->pixels = NULL; 1115 } 1116 1117 static int DSp_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dest) 1118 { 1119 int accelerated; 1120 1121 /* Set initial acceleration on */ 1122 src->flags |= SDL_HWACCEL; 1123 1124 /* Set the surface attributes */ 1125 if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { 1126 if ( ! this->info.blit_hw_A ) { 1127 src->flags &= ~SDL_HWACCEL; 1128 } 1129 } 1130 if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { 1131 if ( ! this->info.blit_hw_CC ) { 1132 src->flags &= ~SDL_HWACCEL; 1133 } 1134 } 1135 1136 /* Check to see if final surface blit is accelerated */ 1137 accelerated = !!(src->flags & SDL_HWACCEL); 1138 if ( accelerated ) { 1139 src->map->hw_blit = DSp_HWAccelBlit; 1140 } 1141 return(accelerated); 1142 } 1143 1144 static int DSp_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, 1145 SDL_Surface *dst, SDL_Rect *dstrect) 1146 { 1147 CGrafPtr save_port; 1148 GDHandle save_device; 1149 Rect src_rect, dst_rect; 1150 RGBColor black = { 0, 0, 0 }; 1151 RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF }; 1152 1153 #ifdef DSP_TRY_CC_AND_AA 1154 UInt32 mode; 1155 #endif 1156 1157 SetRect (&src_rect, srcrect->x, srcrect->y, srcrect->x + srcrect->w, srcrect->y + srcrect->h); 1158 SetRect (&dst_rect, dstrect->x, dstrect->y, dstrect->x + dstrect->w, dstrect->y + dstrect->h); 1159 1160 GetGWorld (&save_port, &save_device); 1161 SetGWorld (dst->hwdata->offscreen, NULL); 1162 1163 RGBForeColor (&black); 1164 RGBBackColor (&white); 1165 1166 #ifdef DSP_TRY_CC_AND_AA 1167 1168 if ( (src->flags & SDL_SRCCOLORKEY) && 1169 (src->flags & SDL_SRCALPHA) ) { 1170 1171 OpColor (&(src->hwdata->alpha)); 1172 1173 CopyDeepMask ( GetPortBitMapForCopyBits(src->hwdata->offscreen), 1174 GetPortBitMapForCopyBits(src->hwdata->mask), 1175 GetPortBitMapForCopyBits(dst->hwdata->offscreen), 1176 &src_rect, &src_rect, &dst_rect, 1177 blend, 1178 NULL ); 1179 } 1180 else { 1181 1182 if ( src->flags & SDL_SRCCOLORKEY) { 1183 RGBBackColor (&(src->hwdata->trans) ); 1184 mode = transparent; 1185 } 1186 else if (src->flags & SDL_SRCALPHA) { 1187 1188 OpColor (&(src->hwdata->alpha)); 1189 mode = blend; 1190 } 1191 else { 1192 1193 mode = srcCopy; 1194 } 1195 1196 CopyBits ( GetPortBitMapForCopyBits(src->hwdata->offscreen), 1197 GetPortBitMapForCopyBits(dst->hwdata->offscreen), 1198 &src_rect, &dst_rect, mode, NULL ); 1199 } 1200 #else 1201 1202 CopyBits ( &(((GrafPtr)(src->hwdata->offscreen))->portBits), 1203 &(((GrafPtr)(dst->hwdata->offscreen))->portBits), 1204 &src_rect, &dst_rect, srcCopy, NULL ); 1205 1206 #endif /* DSP_TRY_CC_AND_AA */ 1207 1208 SetGWorld (save_port, save_device); 1209 1210 return(0); 1211 } 1212 1213 static int DSp_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color) 1214 { 1215 CGrafPtr save_port; 1216 GDHandle save_device; 1217 Rect fill_rect; 1218 RGBColor rgb; 1219 1220 SetRect (&fill_rect, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h); 1221 1222 GetGWorld (&save_port, &save_device); 1223 SetGWorld (dst->hwdata->offscreen, NULL); 1224 1225 Index2Color (color, &rgb); 1226 1227 RGBForeColor (&rgb); 1228 PaintRect (&fill_rect); 1229 1230 SetGWorld (save_port, save_device); 1231 1232 return(0); 1233 } 1234 1235 static int DSp_FlipHWSurface(_THIS, SDL_Surface *surface) 1236 { 1237 if ( (surface->flags & SDL_HWSURFACE) ) { 1238 CGrafPtr dsp_front_buffer, save_port; 1239 Rect rect; 1240 1241 #if ! TARGET_API_MAC_OSX 1242 unsigned int old_count; 1243 #endif 1244 1245 /* pseudo page flipping for VRAM back buffer*/ 1246 DSpContext_GetFrontBuffer (dsp_context, &dsp_front_buffer); 1247 SetRect (&rect, 0, 0, surface->w-1, surface->h-1); 1248 1249 GetPort ((GrafPtr *)&save_port); 1250 SetPort ((GrafPtr)dsp_front_buffer); 1251 1252 /* wait for retrace */ 1253 /* I have tried doing the swap in interrupt routine (VBL Proc) to do */ 1254 /* it asynchronously, but apparently CopyBits isn't interrupt safe */ 1255 1256 #if ! TARGET_API_MAC_OSX 1257 #ifndef DSP_NO_SYNC_VBL 1258 old_count = retrace_count; 1259 while (old_count == retrace_count) 1260 ; 1261 #endif 1262 #endif 1263 1264 CopyBits ( GetPortBitMapForCopyBits(dsp_back_buffer), 1265 GetPortBitMapForCopyBits(dsp_front_buffer), 1266 &rect, &rect, srcCopy, NULL ); 1267 1268 SetPort ((GrafPtr)save_port); 1269 1270 } else { 1271 /* not really page flipping at all: DSp just blits the dirty rectangles from DSp_UpdateRects */ 1272 Boolean busy_flag; 1273 DSpContext_SwapBuffers (dsp_context, NULL, &busy_flag); /* this waits for VBL */ 1274 DSpContext_GetBackBuffer (dsp_context, kDSpBufferKind_Normal, &dsp_back_buffer); 1275 surface->pixels = GetPixBaseAddr( GetPortPixMap(dsp_back_buffer) ); 1276 } 1277 return(0); 1278 } 1279 1280 static int DSp_LockHWSurface(_THIS, SDL_Surface *surface) 1281 { 1282 if ( LockPixels (GetGWorldPixMap (surface->hwdata->offscreen)) ) 1283 return 0; 1284 else 1285 return -1; 1286 } 1287 1288 static void DSp_UnlockHWSurface(_THIS, SDL_Surface *surface) 1289 { 1290 UnlockPixels (GetGWorldPixMap (surface->hwdata->offscreen)); 1291 } 1292 1293 static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *sdl_rects) 1294 { 1295 return; 1296 } 1297 1298 static void DSp_DSpUpdate(_THIS, int numrects, SDL_Rect *sdl_rects) 1299 { 1300 #if ! TARGET_API_MAC_OSX /* Unsupported DSp in here */ 1301 int i; 1302 Rect rect; 1303 1304 for (i = 0; i < numrects; i++) { 1305 1306 rect.top = sdl_rects[i].y; 1307 rect.left = sdl_rects[i].x; 1308 rect.bottom = sdl_rects[i].h + sdl_rects[i].y; 1309 rect.right = sdl_rects[i].w + sdl_rects[i].x; 1310 1311 DSpContext_InvalBackBufferRect (dsp_context, &rect); 1312 } 1313 #endif 1314 } 1315 1316 static int DSp_CreatePalette(_THIS) { 1317 1318 1319 /* Create our palette */ 1320 SDL_CTab = (CTabHandle)NewHandle(sizeof(ColorSpec)*256 + 8); 1321 if ( SDL_CTab == nil ) { 1322 SDL_OutOfMemory(); 1323 return(-1); 1324 } 1325 (**SDL_CTab).ctSeed = GetCTSeed(); 1326 (**SDL_CTab).ctFlags = 0; 1327 (**SDL_CTab).ctSize = 255; 1328 CTabChanged(SDL_CTab); 1329 SDL_CPal = NewPalette(256, SDL_CTab, pmExplicit+pmTolerant, 0); 1330 1331 return 0; 1332 } 1333 1334 static int DSp_DestroyPalette(_THIS) { 1335 1336 /* Free palette and restore original one */ 1337 if ( SDL_CTab != nil ) { 1338 DisposeHandle((Handle)SDL_CTab); 1339 SDL_CTab = nil; 1340 } 1341 if ( SDL_CPal != nil ) { 1342 DisposePalette(SDL_CPal); 1343 SDL_CPal = nil; 1344 } 1345 RestoreDeviceClut(SDL_Display); 1346 1347 return (0); 1348 } 1349 1350 static int DSp_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) 1351 { 1352 CTabHandle cTab; 1353 1354 int i; 1355 1356 cTab = SDL_CTab; 1357 1358 /* Verify the range of colors */ 1359 if ( (firstcolor+ncolors) > ((**cTab).ctSize+1) ) { 1360 return(0); 1361 } 1362 1363 /* Set the screen palette and update the display */ 1364 for(i = 0; i < ncolors; i++) { 1365 int j = firstcolor + i; 1366 (**cTab).ctTable[j].value = j; 1367 (**cTab).ctTable[j].rgb.red = colors[i].r << 8 | colors[i].r; 1368 (**cTab).ctTable[j].rgb.green = colors[i].g << 8 | colors[i].g; 1369 (**cTab).ctTable[j].rgb.blue = colors[i].b << 8 | colors[i].b; 1370 } 1371 1372 SetGDevice(SDL_Display); 1373 SetEntries(0, (**cTab).ctSize, (ColorSpec *)&(**cTab).ctTable); 1374 1375 return(1); 1376 } 1377 1378 void DSp_VideoQuit(_THIS) 1379 { 1380 int i; 1381 1382 /* Free current video mode */ 1383 DSp_UnsetVideoMode(this, this->screen); 1384 1385 /* Free Palette and restore original */ 1386 DSp_DestroyPalette (this); 1387 1388 #if SDL_MACCLASSIC_GAMMA_SUPPORT 1389 Mac_QuitGamma(this); 1390 #endif 1391 1392 /* Free list of video modes */ 1393 if ( SDL_modelist != NULL ) { 1394 for ( i=0; SDL_modelist[i]; i++ ) { 1395 SDL_free(SDL_modelist[i]); 1396 } 1397 SDL_free(SDL_modelist); 1398 SDL_modelist = NULL; 1399 } 1400 1401 /* Unload DrawSprocket */ 1402 DSpShutdown (); 1403 } 1404 1405 #if SDL_VIDEO_OPENGL 1406 1407 /* swap buffers with v-sync */ 1408 static void DSp_GL_SwapBuffers (_THIS) { 1409 1410 #ifndef DSP_NO_SYNC_OPENGL 1411 1412 unsigned int old_count; 1413 1414 old_count = retrace_count; 1415 while (old_count == retrace_count) 1416 ; 1417 #endif 1418 1419 aglSwapBuffers (glContext); 1420 } 1421 1422 #endif 1423
