SDL_QuartzVideo.m
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2009 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
20
slouken@libsdl.org
22
#include "SDL_config.h"
23
24
#include "SDL_QuartzVideo.h"
25
#include "SDL_QuartzWindow.h"
27
28
#ifdef __powerpc__ /* I'm gambling they fixed this by 10.4. --ryan. */
/*
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
Add methods to get at private members of NSScreen.
Since there is a bug in Apple's screen switching code
that does not update this variable when switching
to fullscreen, we'll set it manually (but only for the
main screen).
*/
@interface NSScreen (NSScreenAccess)
- (void) setFrame:(NSRect)frame;
@end
@implementation NSScreen (NSScreenAccess)
- (void) setFrame:(NSRect)frame;
{
_frame = frame;
}
@end
45
46
47
48
49
50
51
52
53
static inline void QZ_SetFrame(NSScreen *nsscreen, NSRect frame)
{
[nsscreen setFrame:frame];
}
#else
static inline void QZ_SetFrame(NSScreen *nsscreen, NSRect frame)
{
}
#endif
55
56
57
58
59
60
61
62
63
64
@interface SDLTranslatorResponder : NSTextView
{
}
- (void) doCommandBySelector:(SEL)myselector;
@end
@implementation SDLTranslatorResponder
- (void) doCommandBySelector:(SEL) myselector {}
@end
65
66
/* absent in 10.3.9. */
CG_EXTERN CGImageRef CGBitmapContextCreateImage (CGContextRef);
67
68
69
70
71
72
73
74
75
76
77
/* Bootstrap functions */
static int QZ_Available ();
static SDL_VideoDevice* QZ_CreateDevice (int device_index);
static void QZ_DeleteDevice (SDL_VideoDevice *device);
/* Initialization, Query, Setup, and Redrawing functions */
static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format);
static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format,
Uint32 flags);
78
static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop);
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
static SDL_Surface* QZ_SetVideoMode (_THIS, SDL_Surface *current,
int width, int height, int bpp,
Uint32 flags);
static int QZ_ToggleFullScreen (_THIS, int on);
static int QZ_SetColors (_THIS, int first_color,
int num_colors, SDL_Color *colors);
static int QZ_LockDoubleBuffer (_THIS, SDL_Surface *surface);
static void QZ_UnlockDoubleBuffer (_THIS, SDL_Surface *surface);
static int QZ_ThreadFlip (_THIS);
static int QZ_FlipDoubleBuffer (_THIS, SDL_Surface *surface);
static void QZ_DoubleBufferUpdate (_THIS, int num_rects, SDL_Rect *rects);
static void QZ_DirectUpdate (_THIS, int num_rects, SDL_Rect *rects);
static void QZ_UpdateRects (_THIS, int num_rects, SDL_Rect *rects);
static void QZ_VideoQuit (_THIS);
/* Hardware surface functions (for fullscreen mode only) */
#if 0 /* Not used (apparently, it's really slow) */
static int QZ_FillHWRect (_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);
#endif
static int QZ_LockHWSurface(_THIS, SDL_Surface *surface);
static void QZ_UnlockHWSurface(_THIS, SDL_Surface *surface);
103
static int QZ_AllocHWSurface(_THIS, SDL_Surface *surface);
104
105
static void QZ_FreeHWSurface (_THIS, SDL_Surface *surface);
/* static int QZ_FlipHWSurface (_THIS, SDL_Surface *surface); */
106
107
108
/* Bootstrap binding, enables entry point into the driver */
VideoBootStrap QZ_bootstrap = {
109
"Quartz", "Mac OS X CoreGraphics", QZ_Available, QZ_CreateDevice
113
/* Bootstrap functions */
114
115
static int QZ_Available ()
{
116
117
118
return 1;
}
119
120
static SDL_VideoDevice* QZ_CreateDevice (int device_index)
{
121
#pragma unused (device_index)
122
123
124
125
SDL_VideoDevice *device;
SDL_PrivateVideoData *hidden;
126
127
device = (SDL_VideoDevice*) SDL_malloc (sizeof (*device) );
hidden = (SDL_PrivateVideoData*) SDL_malloc (sizeof (*hidden) );
128
129
130
131
if (device == NULL || hidden == NULL)
SDL_OutOfMemory ();
132
133
SDL_memset (device, 0, sizeof (*device) );
SDL_memset (hidden, 0, sizeof (*hidden) );
135
136
137
138
139
140
device->hidden = hidden;
device->VideoInit = QZ_VideoInit;
device->ListModes = QZ_ListModes;
device->SetVideoMode = QZ_SetVideoMode;
device->ToggleFullScreen = QZ_ToggleFullScreen;
141
device->UpdateMouse = QZ_UpdateMouse;
142
143
144
device->SetColors = QZ_SetColors;
/* device->UpdateRects = QZ_UpdateRects; this is determined by SetVideoMode() */
device->VideoQuit = QZ_VideoQuit;
146
147
device->LockHWSurface = QZ_LockHWSurface;
device->UnlockHWSurface = QZ_UnlockHWSurface;
148
device->AllocHWSurface = QZ_AllocHWSurface;
149
150
151
152
153
154
155
156
157
158
159
160
161
device->FreeHWSurface = QZ_FreeHWSurface;
/* device->FlipHWSurface = QZ_FlipHWSurface */;
device->SetGamma = QZ_SetGamma;
device->GetGamma = QZ_GetGamma;
device->SetGammaRamp = QZ_SetGammaRamp;
device->GetGammaRamp = QZ_GetGammaRamp;
device->GL_GetProcAddress = QZ_GL_GetProcAddress;
device->GL_GetAttribute = QZ_GL_GetAttribute;
device->GL_MakeCurrent = QZ_GL_MakeCurrent;
device->GL_SwapBuffers = QZ_GL_SwapBuffers;
device->GL_LoadLibrary = QZ_GL_LoadLibrary;
163
164
165
166
167
168
169
170
171
172
173
174
175
176
device->FreeWMCursor = QZ_FreeWMCursor;
device->CreateWMCursor = QZ_CreateWMCursor;
device->ShowWMCursor = QZ_ShowWMCursor;
device->WarpWMCursor = QZ_WarpWMCursor;
device->MoveWMCursor = QZ_MoveWMCursor;
device->CheckMouseMode = QZ_CheckMouseMode;
device->InitOSKeymap = QZ_InitOSKeymap;
device->PumpEvents = QZ_PumpEvents;
device->SetCaption = QZ_SetCaption;
device->SetIcon = QZ_SetIcon;
device->IconifyWindow = QZ_IconifyWindow;
/*device->GetWMInfo = QZ_GetWMInfo;*/
device->GrabInput = QZ_GrabInput;
178
179
180
181
182
183
184
185
/*
* This is a big hassle, needing QuickDraw and QuickTime on older
* systems, and god knows what on 10.6, so we immediately fail here,
* which causes SDL to make an RGB surface and manage the YUV overlay
* in software. Sorry. Use SDL 1.3 if you want YUV rendering in a pixel
* shader. :)
*/
/*device->CreateYUVOverlay = QZ_CreateYUVOverlay;*/
186
187
device->free = QZ_DeleteDevice;
189
190
191
return device;
}
192
193
static void QZ_DeleteDevice (SDL_VideoDevice *device)
{
194
195
SDL_free (device->hidden);
SDL_free (device);
198
199
static int QZ_VideoInit (_THIS, SDL_PixelFormat *video_format)
{
200
NSRect r = NSMakeRect(0.0, 0.0, 0.0, 0.0);
201
const char *env = NULL;
203
204
/* Initialize the video settings; this data persists between mode switches */
display_id = kCGDirectMainDisplay;
206
207
208
save_mode = CGDisplayCurrentMode (display_id);
mode_list = CGDisplayAvailableModes (display_id);
palette = CGPaletteCreateDefaultColorPalette ();
210
/* Allow environment override of screensaver disable. */
211
env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
212
213
214
215
216
217
218
219
220
if ( env ) {
allow_screensaver = SDL_atoi(env);
} else {
#ifdef SDL_VIDEO_DISABLE_SCREENSAVER
allow_screensaver = 0;
#else
allow_screensaver = 1;
#endif
}
222
223
224
/* Gather some information that is useful to know about the display */
CFNumberGetValue (CFDictionaryGetValue (save_mode, kCGDisplayBitsPerPixel),
kCFNumberSInt32Type, &device_bpp);
226
227
228
229
230
231
CFNumberGetValue (CFDictionaryGetValue (save_mode, kCGDisplayWidth),
kCFNumberSInt32Type, &device_width);
CFNumberGetValue (CFDictionaryGetValue (save_mode, kCGDisplayHeight),
kCFNumberSInt32Type, &device_height);
232
233
234
235
236
/* Determine the current screen size */
this->info.current_w = device_width;
this->info.current_h = device_height;
/* Determine the default screen depth */
237
238
video_format->BitsPerPixel = device_bpp;
239
240
/* Set misc globals */
current_grab_mode = SDL_GRAB_OFF;
241
cursor_should_be_visible = YES;
242
cursor_visible = YES;
243
current_mods = 0;
244
field_edit = [[SDLTranslatorResponder alloc] initWithFrame:r];
246
247
if ( Gestalt(gestaltSystemVersion, &system_version) != noErr )
system_version = 0;
249
250
251
/* register for sleep notifications so wake from sleep generates SDL_VIDEOEXPOSE */
QZ_RegisterForSleepNotifications (this);
252
253
254
/* Fill in some window manager capabilities */
this->info.wm_available = 1;
255
return 0;
258
259
static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format, Uint32 flags)
{
260
CFIndex num_modes;
261
262
263
CFIndex i;
int list_size = 0;
265
266
267
/* Any windowed mode is acceptable */
if ( (flags & SDL_FULLSCREEN) == 0 )
return (SDL_Rect**)-1;
269
/* Free memory from previous call, if any */
270
if ( client_mode_list != NULL ) {
272
int i;
274
for (i = 0; client_mode_list[i] != NULL; i++)
275
SDL_free (client_mode_list[i]);
277
SDL_free (client_mode_list);
278
client_mode_list = NULL;
281
282
num_modes = CFArrayGetCount (mode_list);
283
/* Build list of modes with the requested bpp */
284
for (i = 0; i < num_modes; i++) {
286
287
CFDictionaryRef onemode;
CFNumberRef number;
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
int bpp;
onemode = CFArrayGetValueAtIndex (mode_list, i);
number = CFDictionaryGetValue (onemode, kCGDisplayBitsPerPixel);
CFNumberGetValue (number, kCFNumberSInt32Type, &bpp);
if (bpp == format->BitsPerPixel) {
int intvalue;
int hasMode;
int width, height;
number = CFDictionaryGetValue (onemode, kCGDisplayWidth);
CFNumberGetValue (number, kCFNumberSInt32Type, &intvalue);
width = (Uint16) intvalue;
number = CFDictionaryGetValue (onemode, kCGDisplayHeight);
CFNumberGetValue (number, kCFNumberSInt32Type, &intvalue);
height = (Uint16) intvalue;
/* Check if mode is already in the list */
{
int i;
hasMode = SDL_FALSE;
for (i = 0; i < list_size; i++) {
313
314
if (client_mode_list[i]->w == width &&
client_mode_list[i]->h == height) {
315
316
317
hasMode = SDL_TRUE;
break;
}
320
321
322
323
324
325
326
327
/* Grow the list and add mode to the list */
if ( ! hasMode ) {
SDL_Rect *rect;
list_size++;
328
329
if (client_mode_list == NULL)
client_mode_list = (SDL_Rect**)
330
SDL_malloc (sizeof(*client_mode_list) * (list_size+1) );
332
client_mode_list = (SDL_Rect**)
333
SDL_realloc (client_mode_list, sizeof(*client_mode_list) * (list_size+1));
335
rect = (SDL_Rect*) SDL_malloc (sizeof(**client_mode_list));
337
if (client_mode_list == NULL || rect == NULL) {
338
339
340
341
SDL_OutOfMemory ();
return NULL;
}
342
rect->x = rect->y = 0;
343
344
345
rect->w = width;
rect->h = height;
346
347
client_mode_list[list_size-1] = rect;
client_mode_list[list_size] = NULL;
352
353
354
355
356
/* Sort list largest to smallest (by area) */
{
int i, j;
for (i = 0; i < list_size; i++) {
for (j = 0; j < list_size-1; j++) {
358
int area1, area2;
359
360
area1 = client_mode_list[j]->w * client_mode_list[j]->h;
area2 = client_mode_list[j+1]->w * client_mode_list[j+1]->h;
362
if (area1 < area2) {
363
364
365
SDL_Rect *tmp = client_mode_list[j];
client_mode_list[j] = client_mode_list[j+1];
client_mode_list[j+1] = tmp;
366
367
368
369
}
}
}
}
370
return client_mode_list;
373
374
375
376
377
378
379
380
381
382
383
static SDL_bool QZ_WindowPosition(_THIS, int *x, int *y)
{
const char *window = getenv("SDL_VIDEO_WINDOW_POS");
if ( window ) {
if ( sscanf(window, "%d,%d", x, y) == 2 ) {
return SDL_TRUE;
}
}
return SDL_FALSE;
}
384
385
static void QZ_UnsetVideoMode (_THIS, BOOL to_desktop)
{
386
/* Reset values that may change between switches */
387
388
389
390
391
392
this->info.blit_fill = 0;
this->FillHWRect = NULL;
this->UpdateRects = NULL;
this->LockHWSurface = NULL;
this->UnlockHWSurface = NULL;
393
394
395
396
397
398
if (cg_context) {
CGContextFlush (cg_context);
CGContextRelease (cg_context);
cg_context = nil;
}
399
/* Release fullscreen resources */
400
if ( mode_flags & SDL_FULLSCREEN ) {
402
403
NSRect screen_rect;
404
/* Release double buffer stuff */
405
if ( mode_flags & SDL_DOUBLEBUF) {
406
407
408
409
410
quit_thread = YES;
SDL_SemPost (sem1);
SDL_WaitThread (thread, NULL);
SDL_DestroySemaphore (sem1);
SDL_DestroySemaphore (sem2);
411
SDL_free (sw_buffers[0]);
416
417
NSCAssert([ qz_window delegate ] == nil, @"full screen window shouldn't have a delegate"); /* if that should ever change, we'd have to release it here */
[ qz_window close ]; /* includes release because [qz_window isReleasedWhenClosed] */
421
422
423
424
425
426
/*
Release the OpenGL context
Do this first to avoid trash on the display before fade
*/
if ( mode_flags & SDL_OPENGL ) {
427
QZ_TearDownOpenGL (this);
428
429
CGLSetFullScreen (NULL);
}
430
if (to_desktop) {
432
433
434
435
436
437
438
439
/* Restore original screen resolution/bpp */
CGDisplaySwitchToMode (display_id, save_mode);
CGReleaseAllDisplays ();
/*
Reset the main screen's rectangle
See comment in QZ_SetVideoFullscreen for why we do this
*/
screen_rect = NSMakeRect(0,0,device_width,device_height);
440
QZ_SetFrame([ NSScreen mainScreen ], screen_rect);
443
/* Release window mode resources */
444
else {
445
446
447
id delegate = [ qz_window delegate ];
[ qz_window close ]; /* includes release because [qz_window isReleasedWhenClosed] */
if (delegate != nil) [ delegate release ];
448
qz_window = nil;
449
window_view = nil;
451
452
453
/* Release the OpenGL context */
if ( mode_flags & SDL_OPENGL )
QZ_TearDownOpenGL (this);
456
457
/* Signal successful teardown */
video_set = SDL_FALSE;
458
459
460
}
static SDL_Surface* QZ_SetVideoFullScreen (_THIS, SDL_Surface *current, int width,
461
462
int height, int bpp, Uint32 flags)
{
463
boolean_t exact_match = 0;
464
NSRect screen_rect;
465
CGError error;
467
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
469
470
471
472
473
/* Fade to black to hide resolution-switching flicker (and garbage
that is displayed by a destroyed OpenGL context, if applicable) */
if ( CGAcquireDisplayFadeReservation (5, &fade_token) == kCGErrorSuccess ) {
CGDisplayFade (fade_token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
}
475
476
/* Destroy any previous mode */
if (video_set == SDL_TRUE)
477
QZ_UnsetVideoMode (this, FALSE);
479
480
481
482
483
484
/* Sorry, QuickDraw was ripped out. */
if (getenv("SDL_NSWindowPointer") || getenv("SDL_NSQuickDrawViewPointer")) {
SDL_SetError ("Embedded QuickDraw windows are no longer supported");
goto ERR_NO_MATCH;
}
485
/* See if requested mode exists */
486
487
488
mode = CGDisplayBestModeForParameters (display_id, bpp, width,
height, &exact_match);
489
490
/* Require an exact match to the requested mode */
if ( ! exact_match ) {
491
SDL_SetError ("Failed to find display resolution: %dx%dx%d", width, height, bpp);
492
493
goto ERR_NO_MATCH;
}
495
/* Put up the blanking window (a window above all other windows) */
496
497
498
499
500
501
if (getenv ("SDL_SINGLEDISPLAY"))
error = CGDisplayCapture (display_id);
else
error = CGCaptureAllDisplays ();
if ( CGDisplayNoErr != error ) {
502
503
504
SDL_SetError ("Failed capturing display");
goto ERR_NO_CAPTURE;
}
506
507
508
509
510
/* Do the physical switch */
if ( CGDisplayNoErr != CGDisplaySwitchToMode (display_id, mode) ) {
SDL_SetError ("Failed switching display resolution");
goto ERR_NO_SWITCH;
}
512
513
514
current->pixels = (Uint32*) CGDisplayBaseAddress (display_id);
current->pitch = CGDisplayBytesPerRow (display_id);
515
current->flags = 0;
516
517
current->w = width;
current->h = height;
518
current->flags |= SDL_FULLSCREEN;
519
current->flags |= SDL_HWSURFACE;
520
current->flags |= SDL_PREALLOC;
521
522
/* current->hwdata = (void *) CGDisplayGetDrawingContext (display_id); */
523
524
525
this->UpdateRects = QZ_DirectUpdate;
this->LockHWSurface = QZ_LockHWSurface;
this->UnlockHWSurface = QZ_UnlockHWSurface;
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
/* Setup double-buffer emulation */
if ( flags & SDL_DOUBLEBUF ) {
/*
Setup a software backing store for reasonable results when
double buffering is requested (since a single-buffered hardware
surface looks hideous).
The actual screen blit occurs in a separate thread to allow
other blitting while waiting on the VBL (and hence results in higher framerates).
*/
this->LockHWSurface = NULL;
this->UnlockHWSurface = NULL;
this->UpdateRects = NULL;
current->flags |= (SDL_HWSURFACE|SDL_DOUBLEBUF);
this->UpdateRects = QZ_DoubleBufferUpdate;
this->LockHWSurface = QZ_LockDoubleBuffer;
this->UnlockHWSurface = QZ_UnlockDoubleBuffer;
this->FlipHWSurface = QZ_FlipDoubleBuffer;
548
current->pixels = SDL_malloc (current->pitch * current->h * 2);
549
550
551
552
553
554
555
556
557
558
559
560
if (current->pixels == NULL) {
SDL_OutOfMemory ();
goto ERR_DOUBLEBUF;
}
sw_buffers[0] = current->pixels;
sw_buffers[1] = (Uint8*)current->pixels + current->pitch * current->h;
quit_thread = NO;
sem1 = SDL_CreateSemaphore (0);
sem2 = SDL_CreateSemaphore (1);
thread = SDL_CreateThread ((int (*)(void *))QZ_ThreadFlip, this);
563
564
if ( CGDisplayCanSetPalette (display_id) )
current->flags |= SDL_HWPALETTE;
566
567
568
569
570
/* Check if we should recreate the window */
if (qz_window == nil) {
/* Manually create a window, avoids having a nib file resource */
qz_window = [ [ SDL_QuartzWindow alloc ]
initWithContentRect:contentRect
571
styleMask:0
572
573
574
575
576
577
578
579
580
581
backing:NSBackingStoreBuffered
defer:NO ];
if (qz_window != nil) {
[ qz_window setAcceptsMouseMovedEvents:YES ];
[ qz_window setViewsNeedDisplay:NO ];
}
}
/* We already have a window, just change its size */
else {
582
583
584
[ qz_window setContentSize:contentRect.size ];
current->flags |= (SDL_NOFRAME|SDL_RESIZABLE) & mode_flags;
[ window_view setFrameSize:contentRect.size ];
587
588
589
590
591
/* Setup OpenGL for a fullscreen context */
if (flags & SDL_OPENGL) {
CGLError err;
CGLContextObj ctx;
593
if ( ! QZ_SetupOpenGL (this, bpp, flags) ) {
594
goto ERR_NO_GL;
597
598
599
600
601
602
/* Initialize the NSView and add it to our window. The presence of a valid window and
view allow the cursor to be changed whilst in fullscreen.*/
window_view = [ [ NSView alloc ] initWithFrame:contentRect ];
[ [ qz_window contentView ] addSubview:window_view ];
[ window_view release ];
603
ctx = QZ_GetCGLContextObj (gl_context);
604
err = CGLSetFullScreen (ctx);
606
if (err) {
607
SDL_SetError ("Error setting OpenGL fullscreen: %s", CGLErrorString(err));
608
609
goto ERR_NO_GL;
}
611
[ gl_context makeCurrentContext];
612
613
614
615
glClear (GL_COLOR_BUFFER_BIT);
[ gl_context flushBuffer ];
617
618
619
620
621
current->flags |= SDL_OPENGL;
}
/* If we don't hide menu bar, it will get events and interrupt the program */
HideMenuBar ();
623
624
625
626
627
/* Fade in again (asynchronously) */
if ( fade_token != kCGDisplayFadeReservationInvalidToken ) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation(fade_token);
}
630
631
632
633
634
There is a bug in Cocoa where NSScreen doesn't synchronize
with CGDirectDisplay, so the main screen's frame is wrong.
As a result, coordinate translation produces incorrect results.
We can hack around this bug by setting the screen rect
ourselves. This hack should be removed if/when the bug is fixed.
635
636
*/
screen_rect = NSMakeRect(0,0,width,height);
637
QZ_SetFrame([ NSScreen mainScreen ], screen_rect);
639
640
/* Save the flags to ensure correct tear-down */
mode_flags = current->flags;
645
646
return current;
647
/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */
648
649
650
ERR_NO_GL:
ERR_DOUBLEBUF: CGDisplaySwitchToMode (display_id, save_mode);
ERR_NO_SWITCH: CGReleaseAllDisplays ();
651
652
653
654
655
656
ERR_NO_CAPTURE:
ERR_NO_MATCH: if ( fade_token != kCGDisplayFadeReservationInvalidToken ) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
}
return NULL;
657
658
659
}
static SDL_Surface* QZ_SetVideoWindowed (_THIS, SDL_Surface *current, int width,
660
661
int height, int *bpp, Uint32 flags)
{
662
unsigned int style;
663
NSRect contentRect;
664
665
int center_window = 1;
int origin_x, origin_y;
666
CGDisplayFadeReservationToken fade_token = kCGDisplayFadeReservationInvalidToken;
668
669
current->flags = 0;
current->w = width;
670
current->h = height;
671
672
contentRect = NSMakeRect (0, 0, width, height);
674
675
676
677
678
679
680
/*
Check if we should completely destroy the previous mode
- If it is fullscreen
- If it has different noframe or resizable attribute
- If it is OpenGL (since gl attributes could be different)
- If new mode is OpenGL, but previous mode wasn't
*/
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
if (video_set == SDL_TRUE) {
if (mode_flags & SDL_FULLSCREEN) {
/* Fade to black to hide resolution-switching flicker (and garbage
that is displayed by a destroyed OpenGL context, if applicable) */
if (CGAcquireDisplayFadeReservation (5, &fade_token) == kCGErrorSuccess) {
CGDisplayFade (fade_token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
}
QZ_UnsetVideoMode (this, TRUE);
}
else if ( ((mode_flags ^ flags) & (SDL_NOFRAME|SDL_RESIZABLE)) ||
(mode_flags & SDL_OPENGL) ||
(flags & SDL_OPENGL) ) {
QZ_UnsetVideoMode (this, TRUE);
}
}
697
698
699
700
701
702
/* Sorry, QuickDraw was ripped out. */
if (getenv("SDL_NSWindowPointer") || getenv("SDL_NSQuickDrawViewPointer")) {
SDL_SetError ("Embedded QuickDraw windows are no longer supported");
if (fade_token != kCGDisplayFadeReservationInvalidToken) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
704
return NULL;
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
/* Check if we should recreate the window */
if (qz_window == nil) {
/* Set the window style based on input flags */
if ( flags & SDL_NOFRAME ) {
style = NSBorderlessWindowMask;
current->flags |= SDL_NOFRAME;
} else {
style = NSTitledWindowMask;
style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);
if ( flags & SDL_RESIZABLE ) {
style |= NSResizableWindowMask;
current->flags |= SDL_RESIZABLE;
}
}
723
724
725
726
727
728
729
730
731
/* Manually create a window, avoids having a nib file resource */
qz_window = [ [ SDL_QuartzWindow alloc ]
initWithContentRect:contentRect
styleMask:style
backing:NSBackingStoreBuffered
defer:NO ];
if (qz_window == nil) {
SDL_SetError ("Could not create the Cocoa window");
732
733
734
735
if (fade_token != kCGDisplayFadeReservationInvalidToken) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
}
736
737
return NULL;
}
739
/*[ qz_window setReleasedWhenClosed:YES ];*/ /* no need to set this as it's the default for NSWindows */
740
741
742
QZ_SetCaption(this, this->wm_title, this->wm_icon);
[ qz_window setAcceptsMouseMovedEvents:YES ];
[ qz_window setViewsNeedDisplay:NO ];
743
744
745
746
747
if ( QZ_WindowPosition(this, &origin_x, &origin_y) ) {
/* have to flip the Y value (NSPoint is lower left corner origin) */
[ qz_window setFrameTopLeftPoint:NSMakePoint((float) origin_x, (float) (this->info.current_h - origin_y))];
center_window = 0;
748
} else if ( center_window ) {
749
750
[ qz_window center ];
}
752
[ qz_window setDelegate:
754
[ qz_window setContentView: [ [ [ SDL_QuartzView alloc ] init ] autorelease ] ];
755
756
757
}
/* We already have a window, just change its size */
else {
758
759
760
[ qz_window setContentSize:contentRect.size ];
current->flags |= (SDL_NOFRAME|SDL_RESIZABLE) & mode_flags;
[ window_view setFrameSize:contentRect.size ];
763
/* For OpenGL, we bind the context to a subview */
764
if ( flags & SDL_OPENGL ) {
766
if ( ! QZ_SetupOpenGL (this, *bpp, flags) ) {
767
768
769
770
if (fade_token != kCGDisplayFadeReservationInvalidToken) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
}
771
772
return NULL;
}
774
window_view = [ [ NSView alloc ] initWithFrame:contentRect ];
775
[ window_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
776
777
778
[ [ qz_window contentView ] addSubview:window_view ];
[ gl_context setView: window_view ];
[ window_view release ];
779
[ gl_context makeCurrentContext];
780
[ qz_window makeKeyAndOrderFront:nil ];
781
782
current->flags |= SDL_OPENGL;
}
783
/* For 2D, we build a CGBitmapContext */
785
CGColorSpaceRef cgColorspace;
787
788
789
/* Only recreate the view if it doesn't already exist */
if (window_view == nil) {
790
window_view = [ [ NSView alloc ] initWithFrame:contentRect ];
791
[ window_view setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
792
793
794
795
796
[ [ qz_window contentView ] addSubview:window_view ];
[ window_view release ];
[ qz_window makeKeyAndOrderFront:nil ];
}
797
798
799
800
801
802
803
804
805
cgColorspace = CGColorSpaceCreateDeviceRGB();
current->pitch = 4 * current->w;
current->pixels = SDL_malloc (current->h * current->pitch);
cg_context = CGBitmapContextCreate (current->pixels, current->w, current->h,
8, current->pitch, cgColorspace,
kCGImageAlphaNoneSkipFirst);
CGColorSpaceRelease (cgColorspace);
806
current->flags |= SDL_SWSURFACE;
807
current->flags |= SDL_ASYNCBLIT;
808
current->hwdata = (void *) cg_context;
809
810
this->UpdateRects = QZ_UpdateRects;
811
812
this->LockHWSurface = QZ_LockHWSurface;
this->UnlockHWSurface = QZ_UnlockHWSurface;
815
816
/* Save flags to ensure correct teardown */
mode_flags = current->flags;
818
819
820
821
822
823
/* Fade in again (asynchronously) if we came from a fullscreen mode and faded to black */
if (fade_token != kCGDisplayFadeReservationInvalidToken) {
CGDisplayFade (fade_token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
CGReleaseDisplayFadeReservation (fade_token);
}
824
825
826
return current;
}
827
static SDL_Surface* QZ_SetVideoMode (_THIS, SDL_Surface *current, int width,
828
829
int height, int bpp, Uint32 flags)
{
830
current->flags = 0;
831
current->pixels = NULL;
833
834
835
836
837
838
839
840
/* Setup full screen video */
if ( flags & SDL_FULLSCREEN ) {
current = QZ_SetVideoFullScreen (this, current, width, height, bpp, flags );
if (current == NULL)
return NULL;
}
/* Setup windowed video */
else {
841
842
/* Force bpp to 32 */
bpp = 32;
843
current = QZ_SetVideoWindowed (this, current, width, height, &bpp, flags);
844
845
846
if (current == NULL)
return NULL;
}
848
849
/* Setup the new pixel format */
{
850
851
852
853
854
int amask = 0,
rmask = 0,
gmask = 0,
bmask = 0;
855
856
switch (bpp) {
case 16: /* (1)-5-5-5 RGB */
857
amask = 0;
858
859
860
rmask = 0x7C00;
gmask = 0x03E0;
bmask = 0x001F;
861
862
863
864
865
break;
case 24:
SDL_SetError ("24bpp is not available");
return NULL;
case 32: /* (8)-8-8-8 ARGB */
866
amask = 0x00000000;
867
868
869
870
871
872
873
874
if ( flags & SDL_FULLSCREEN )
{
rmask = 0x00FF0000;
gmask = 0x0000FF00;
bmask = 0x000000FF;
}
else
{
875
#ifdef __LITTLE_ENDIAN__
876
877
878
rmask = 0x0000FF00;
gmask = 0x00FF0000;
bmask = 0xFF000000;
880
881
882
rmask = 0x00FF0000;
gmask = 0x0000FF00;
bmask = 0x000000FF;
885
886
break;
}
888
889
if ( ! SDL_ReallocFormat (current, bpp,
rmask, gmask, bmask, amask ) ) {
890
891
SDL_SetError ("Couldn't reallocate pixel format");
return NULL;
895
/* Signal successful completion (used internally) */
896
video_set = SDL_TRUE;
898
899
900
return current;
}
901
902
static int QZ_ToggleFullScreen (_THIS, int on)
{
906
static int QZ_SetColors (_THIS, int first_color, int num_colors,
907
908
SDL_Color *colors)
{
909
910
CGTableCount index;
CGDeviceColor color;
912
for (index = first_color; index < first_color+num_colors; index++) {
914
915
916
917
/* Clamp colors between 0.0 and 1.0 */
color.red = colors->r / 255.0;
color.blue = colors->b / 255.0;
color.green = colors->g / 255.0;
921
922
CGPaletteSetColorAtIndex (palette, color, index);
}
924
925
if ( CGDisplayNoErr != CGDisplaySetPalette (display_id, palette) )
return 0;
927
928
929
return 1;
}
930
931
static int QZ_LockDoubleBuffer (_THIS, SDL_Surface *surface)
{
932
933
934
return 1;
}
935
936
static void QZ_UnlockDoubleBuffer (_THIS, SDL_Surface *surface)
{
939
940
941
/* The VBL delay is based on code by Ian R Ollmann's RezLib <iano@cco.caltech.edu> */
static AbsoluteTime QZ_SecondsToAbsolute ( double seconds )
{
944
UInt64 i;
945
946
947
948
949
950
951
952
Nanoseconds ns;
} temp;
temp.i = seconds * 1000000000.0;
return NanosecondsToAbsolute ( temp.ns );
}
953
954
static int QZ_ThreadFlip (_THIS)
{
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
Uint8 *src, *dst;
int skip, len, h;
/*
Give this thread the highest scheduling priority possible,
in the hopes that it will immediately run after the VBL delay
*/
{
pthread_t current_thread;
int policy;
struct sched_param param;
current_thread = pthread_self ();
pthread_getschedparam (current_thread, &policy, ¶m);
policy = SCHED_RR;
param.sched_priority = sched_get_priority_max (policy);
pthread_setschedparam (current_thread, policy, ¶m);
}
while (1) {
SDL_SemWait (sem1);
if (quit_thread)
return 0;
980
981
982
983
984
985
/*
* We have to add SDL_VideoSurface->offset here, since we might be a
* smaller surface in the center of the framebuffer (you asked for
* a fullscreen resolution smaller than the hardware could supply
* so SDL is centering it in a bigger resolution)...
*/
986
dst = (Uint8 *)CGDisplayBaseAddress (display_id) + SDL_VideoSurface->offset;
987
src = current_buffer + SDL_VideoSurface->offset;
988
989
990
991
992
993
994
995
996
997
998
999
1000
len = SDL_VideoSurface->w * SDL_VideoSurface->format->BytesPerPixel;
h = SDL_VideoSurface->h;
skip = SDL_VideoSurface->pitch;
/* Wait for the VBL to occur (estimated since we don't have a hardware interrupt) */
{
/* The VBL delay is based on Ian Ollmann's RezLib <iano@cco.caltech.edu> */
double refreshRate;
double linesPerSecond;
double target;
double position;
double adjustment;