static int cgl_color_size(struct MPGLContext *ctx)
{
struct cgl_context *p = ctx->priv;
GLint value;
CGLDescribePixelFormat(p->pix, 0, kCGLPFAColorSize, &value);
return value > 16 ? 8 : 5;
}
static void DEBUG_PIXEL_FORMAT(CGLPixelFormatObj pix)
{
const struct PixelFormatDesc p[] = {
{kCGLPFAAllRenderers, "All renderers"},
{kCGLPFADoubleBuffer, "Double buffer"},
{kCGLPFAStereo, "Stereo"},
{kCGLPFAAuxBuffers, "Aux Buffers"},
{kCGLPFAColorSize, "Color Size"},
{kCGLPFAAlphaSize, "Alpha Size"},
{kCGLPFADepthSize, "Depth Size"},
{kCGLPFAStencilSize, "Stencil Size"},
{kCGLPFAAccumSize, "Accum Size"},
{kCGLPFAMinimumPolicy, "Minimum Policy"},
{kCGLPFAMaximumPolicy, "Maximum Policy"},
{kCGLPFAOffScreen, "Off Screen"},
{kCGLPFAFullScreen, "Full Screen"},
{kCGLPFASampleBuffers, "Sample Buffers"},
{kCGLPFASamples, "Samples"} ,
{kCGLPFAAuxDepthStencil, "Depth Stencil"},
{kCGLPFAColorFloat, "Color Float"},
{kCGLPFAMultisample, "Multi Sample"},
{kCGLPFASupersample, "Super Sample"},
{kCGLPFASampleAlpha, "Sample Alpha"},
{kCGLPFARendererID, "RendererID"},
{kCGLPFASingleRenderer, "Single Renderer"},
{kCGLPFANoRecovery, "No Recovery"},
{kCGLPFAAccelerated, "Accelerated"},
{kCGLPFAClosestPolicy, "Closest Policy"},
{kCGLPFARobust, "Robust"},
{kCGLPFABackingStore, "Backing Store"},
{kCGLPFAMPSafe, "MPSafe"},
{kCGLPFAWindow, "Window"},
{kCGLPFAMultiScreen, "Multiscreen"},
{kCGLPFACompliant, "Compliant"},
{kCGLPFADisplayMask, "Display Mask"},
{kCGLPFAPBuffer, "PBuffer"},
{kCGLPFARemotePBuffer, "Remote PBuffer"},
{kCGLPFAVirtualScreenCount, "Accum Size"},
{(CGLPixelFormatAttribute)0,0}
};
int i = 0;
while (p[i].value)
{
long value;
CGLDescribePixelFormat(pix, 0, p[i].value, &value);
if (p[i].value == kCGLPFARendererID)
printf("... %s: 0x%08lx\n", p[i].text, value);
else
printf("... %s: %ld\n", p[i].text, value);
i++;
}
}
void CGLQueryPixelFormat(CGLPixelFormatObj fmt, int* iattrs, int niattrs, int* ivalues) {
// FIXME: think about how specifying this might affect the API
int virtualScreen = 0;
int i;
GLint value;
for (i = 0; i < niattrs && iattrs[i]>0; i++) {
CGLPixelFormatAttribute attr = (CGLPixelFormatAttribute) iattrs[i];
if ( kCGLNoError == CGLDescribePixelFormat(fmt, virtualScreen, attr, &value) ) {
ivalues[i] = value;
} else {
ivalues[i] = 0;
}
}
}
int _glfwPlatformOpenWindow( int width,
int height,
int redbits,
int greenbits,
int bluebits,
int alphabits,
int depthbits,
int stencilbits,
int mode,
_GLFWhints* hints )
{
OSStatus error;
ProcessSerialNumber psn;
unsigned int windowAttributes;
// TO DO: Refactor this function!
_glfwWin.WindowFunctions = ( _glfwWin.Fullscreen ?
&_glfwMacFSWindowFunctions :
&_glfwMacDWWindowFunctions );
// Windowed or fullscreen; AGL or CGL? Quite the mess...
// AGL appears to be the only choice for attaching OpenGL contexts to
// Carbon windows, but it leaves the user no control over fullscreen
// mode stretching. Solution: AGL for windowed, CGL for fullscreen.
if( !_glfwWin.Fullscreen )
{
// create AGL pixel format attribute list
GLint AGLpixelFormatAttributes[256];
int numAGLAttrs = 0;
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_RGBA;
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_DOUBLEBUFFER;
if( hints->Stereo )
{
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_STEREO;
}
_setAGLAttribute( AGL_AUX_BUFFERS, hints->AuxBuffers);
_setAGLAttribute( AGL_RED_SIZE, redbits );
_setAGLAttribute( AGL_GREEN_SIZE, greenbits );
_setAGLAttribute( AGL_BLUE_SIZE, bluebits );
_setAGLAttribute( AGL_ALPHA_SIZE, alphabits );
_setAGLAttribute( AGL_DEPTH_SIZE, depthbits );
_setAGLAttribute( AGL_STENCIL_SIZE, stencilbits );
_setAGLAttribute( AGL_ACCUM_RED_SIZE, hints->AccumRedBits );
_setAGLAttribute( AGL_ACCUM_GREEN_SIZE, hints->AccumGreenBits );
_setAGLAttribute( AGL_ACCUM_BLUE_SIZE, hints->AccumBlueBits );
_setAGLAttribute( AGL_ACCUM_ALPHA_SIZE, hints->AccumAlphaBits );
if( hints->Samples > 1 )
{
_setAGLAttribute( AGL_SAMPLE_BUFFERS_ARB, 1 );
_setAGLAttribute( AGL_SAMPLES_ARB, hints->Samples );
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_NO_RECOVERY;
}
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_NONE;
// create pixel format descriptor
AGLDevice mainMonitor = GetMainDevice();
AGLPixelFormat pixelFormat = aglChoosePixelFormat( &mainMonitor,
1,
AGLpixelFormatAttributes );
if( pixelFormat == NULL )
{
fprintf( stderr, "glfwOpenWindow failing because it can't create a pixel format\n" );
return GL_FALSE;
}
// store pixel format's values for _glfwPlatformGetWindowParam's use
_getAGLAttribute( AGL_ACCELERATED, _glfwWin.Accelerated );
_getAGLAttribute( AGL_RED_SIZE, _glfwWin.RedBits );
_getAGLAttribute( AGL_GREEN_SIZE, _glfwWin.GreenBits );
_getAGLAttribute( AGL_BLUE_SIZE, _glfwWin.BlueBits );
_getAGLAttribute( AGL_ALPHA_SIZE, _glfwWin.AlphaBits );
_getAGLAttribute( AGL_DEPTH_SIZE, _glfwWin.DepthBits );
_getAGLAttribute( AGL_STENCIL_SIZE, _glfwWin.StencilBits );
_getAGLAttribute( AGL_ACCUM_RED_SIZE, _glfwWin.AccumRedBits );
_getAGLAttribute( AGL_ACCUM_GREEN_SIZE, _glfwWin.AccumGreenBits );
_getAGLAttribute( AGL_ACCUM_BLUE_SIZE, _glfwWin.AccumBlueBits );
_getAGLAttribute( AGL_ACCUM_ALPHA_SIZE, _glfwWin.AccumAlphaBits );
_getAGLAttribute( AGL_AUX_BUFFERS, _glfwWin.AuxBuffers );
_getAGLAttribute( AGL_STEREO, _glfwWin.Stereo );
_getAGLAttribute( AGL_SAMPLES_ARB, _glfwWin.Samples );
_glfwWin.RefreshRate = hints->RefreshRate;
// create AGL context
_glfwWin.AGLContext = aglCreateContext( pixelFormat, NULL );
aglDestroyPixelFormat( pixelFormat );
if( _glfwWin.AGLContext == NULL )
{
fprintf( stderr, "glfwOpenWindow failing because it can't create an OpenGL context\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if (_glfwLibrary.Unbundled)
{
if( GetCurrentProcess( &psn ) != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't get its PSN\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if( TransformProcessType( &psn, kProcessTransformToForegroundApplication ) != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't become a foreground application\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
/* Keith Bauer 2007-07-12 - I don't believe this is desirable
if( SetFrontProcess( &psn ) != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't become the front process\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
*/
}
// create window
Rect windowContentBounds;
windowContentBounds.left = 0;
windowContentBounds.top = 0;
windowContentBounds.right = width;
windowContentBounds.bottom = height;
windowAttributes = ( kWindowCloseBoxAttribute \
| kWindowCollapseBoxAttribute \
| kWindowStandardHandlerAttribute );
if( hints->WindowNoResize )
{
windowAttributes |= kWindowLiveResizeAttribute;
}
else
{
windowAttributes |= ( kWindowFullZoomAttribute | kWindowResizableAttribute );
}
error = CreateNewWindow( kDocumentWindowClass,
windowAttributes,
&windowContentBounds,
&( _glfwWin.MacWindow ) );
if( ( error != noErr ) || ( _glfwWin.MacWindow == NULL ) )
{
fprintf( stderr, "glfwOpenWindow failing because it can't create a window\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
_glfwWin.WindowUPP = NewEventHandlerUPP( _glfwWindowEventHandler );
error = InstallWindowEventHandler( _glfwWin.MacWindow,
_glfwWin.WindowUPP,
GetEventTypeCount( GLFW_WINDOW_EVENT_TYPES ),
GLFW_WINDOW_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't install window event handlers\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// Don't care if we fail here
(void)SetWindowTitleWithCFString( _glfwWin.MacWindow, CFSTR( "GLFW Window" ) );
(void)RepositionWindow( _glfwWin.MacWindow,
NULL,
kWindowCenterOnMainScreen );
if( !aglSetDrawable( _glfwWin.AGLContext,
GetWindowPort( _glfwWin.MacWindow ) ) )
{
fprintf( stderr, "glfwOpenWindow failing because it can't draw to the window\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// Make OpenGL context current
if( !aglSetCurrentContext( _glfwWin.AGLContext ) )
{
fprintf( stderr, "glfwOpenWindow failing because it can't make the OpenGL context current\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// show window
ShowWindow( _glfwWin.MacWindow );
return GL_TRUE;
}
else
{
CGDisplayErr cgErr;
CGLError cglErr;
CFDictionaryRef optimalMode;
CGLPixelFormatObj CGLpfObj;
long numCGLvs = 0;
CGLPixelFormatAttribute CGLpixelFormatAttributes[64];
int numCGLAttrs = 0;
// variables for enumerating color depths
GLint rgbColorDepth;
GLint rgbaAccumDepth = 0;
int rgbChannelDepth = 0;
// CGL pixel format attributes
_setCGLAttribute( kCGLPFADisplayMask,
CGDisplayIDToOpenGLDisplayMask( kCGDirectMainDisplay ) );
if( hints->Stereo )
{
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAStereo;
}
if( hints->Samples > 1 )
{
_setCGLAttribute( kCGLPFASamples, (CGLPixelFormatAttribute)hints->Samples );
_setCGLAttribute( kCGLPFASampleBuffers, (CGLPixelFormatAttribute)1 );
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFANoRecovery;
}
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAFullScreen;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFADoubleBuffer;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAAccelerated;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFANoRecovery;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAMinimumPolicy;
_setCGLAttribute( kCGLPFAAccumSize,
(CGLPixelFormatAttribute)( hints->AccumRedBits \
+ hints->AccumGreenBits \
+ hints->AccumBlueBits \
+ hints->AccumAlphaBits ) );
_setCGLAttribute( kCGLPFAAlphaSize, (CGLPixelFormatAttribute)alphabits );
_setCGLAttribute( kCGLPFADepthSize, (CGLPixelFormatAttribute)depthbits );
_setCGLAttribute( kCGLPFAStencilSize, (CGLPixelFormatAttribute)stencilbits );
_setCGLAttribute( kCGLPFAAuxBuffers, (CGLPixelFormatAttribute)hints->AuxBuffers );
CGLpixelFormatAttributes[ numCGLAttrs++ ] = (CGLPixelFormatAttribute)NULL;
// create a suitable pixel format with above attributes..
cglErr = CGLChoosePixelFormat( CGLpixelFormatAttributes,
&CGLpfObj,
&numCGLvs );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
// ..and create a rendering context using that pixel format
cglErr = CGLCreateContext( CGLpfObj, NULL, &_glfwWin.CGLContext );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
// enumerate depth of RGB channels - unlike AGL, CGL works with
// a single parameter reflecting the full depth of the frame buffer
(void)CGLDescribePixelFormat( CGLpfObj, 0, kCGLPFAColorSize, &rgbColorDepth );
if( rgbColorDepth == 24 || rgbColorDepth == 32 )
{
rgbChannelDepth = 8;
}
if( rgbColorDepth == 16 )
{
rgbChannelDepth = 5;
}
// get pixel depth of accumulator - I haven't got the slightest idea
// how this number conforms to any other channel depth than 8 bits,
// so this might end up giving completely knackered results...
(void)CGLDescribePixelFormat( CGLpfObj, 0, kCGLPFAAccumSize, &rgbaAccumDepth );
if( rgbaAccumDepth == 32 )
{
rgbaAccumDepth = 8;
}
// store values of pixel format for _glfwPlatformGetWindowParam's use
_getCGLAttribute( kCGLPFAAccelerated, _glfwWin.Accelerated );
_getCGLAttribute( rgbChannelDepth, _glfwWin.RedBits );
_getCGLAttribute( rgbChannelDepth, _glfwWin.GreenBits );
_getCGLAttribute( rgbChannelDepth, _glfwWin.BlueBits );
_getCGLAttribute( kCGLPFAAlphaSize, _glfwWin.AlphaBits );
_getCGLAttribute( kCGLPFADepthSize, _glfwWin.DepthBits );
_getCGLAttribute( kCGLPFAStencilSize, _glfwWin.StencilBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumRedBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumGreenBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumBlueBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumAlphaBits );
_getCGLAttribute( kCGLPFAAuxBuffers, _glfwWin.AuxBuffers );
_getCGLAttribute( kCGLPFAStereo, _glfwWin.Stereo );
_glfwWin.RefreshRate = hints->RefreshRate;
// destroy our pixel format
(void)CGLDestroyPixelFormat( CGLpfObj );
// capture the display for our application
cgErr = CGCaptureAllDisplays();
if( cgErr != kCGErrorSuccess )
{
return GL_FALSE;
}
// find closest matching NON-STRETCHED display mode..
optimalMode = CGDisplayBestModeForParametersAndRefreshRateWithProperty( kCGDirectMainDisplay,
rgbColorDepth,
width,
/* Check further to the right -> */ height,
hints->RefreshRate,
NULL,
NULL );
if( optimalMode == NULL )
{
return GL_FALSE;
}
// ..and switch to that mode
cgErr = CGDisplaySwitchToMode( kCGDirectMainDisplay, optimalMode );
if( cgErr != kCGErrorSuccess )
{
return GL_FALSE;
}
// switch to our OpenGL context, and bring it up fullscreen
cglErr = CGLSetCurrentContext( _glfwWin.CGLContext );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
cglErr = CGLSetFullScreen( _glfwWin.CGLContext );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
return GL_TRUE;
}
}
int _glfwPlatformOpenWindow( int width, int height,
const _GLFWwndconfig *wndconfig,
const _GLFWfbconfig *fbconfig )
{
OSStatus error;
unsigned int windowAttributes;
ProcessSerialNumber psn;
// TODO: Break up this function!
_glfwWin.windowUPP = NULL;
_glfwWin.mouseUPP = NULL;
_glfwWin.keyboardUPP = NULL;
_glfwWin.commandUPP = NULL;
_glfwWin.window = NULL;
_glfwWin.aglContext = NULL;
_glfwWin.aglPixelFormat = NULL;
_glfwWin.cglContext = NULL;
_glfwWin.cglPixelFormat = NULL;
_glfwWin.refreshRate = wndconfig->refreshRate;
// Fail if OpenGL 3.0 or above was requested
if( wndconfig->glMajor > 2 )
{
fprintf( stderr, "OpenGL 3.0+ is not yet supported on Mac OS X\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if( _glfwLibrary.Unbundled )
{
if( GetCurrentProcess( &psn ) != noErr )
{
fprintf( stderr, "Failed to get the process serial number\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if( TransformProcessType( &psn, kProcessTransformToForegroundApplication ) != noErr )
{
fprintf( stderr, "Failed to become a foreground application\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if( wndconfig->mode == GLFW_FULLSCREEN )
{
if( SetFrontProcess( &psn ) != noErr )
{
fprintf( stderr, "Failed to become the front process\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
}
}
if( !installEventHandlers() )
{
fprintf( stderr,
"Failed to install Carbon application event handlers\n" );
_glfwPlatformTerminate();
return GL_FALSE;
}
// Windowed or fullscreen; AGL or CGL? Quite the mess...
// AGL appears to be the only choice for attaching OpenGL contexts to
// Carbon windows, but it leaves the user no control over fullscreen
// mode stretching. Solution: AGL for windowed, CGL for fullscreen.
if( wndconfig->mode == GLFW_WINDOW )
{
// create AGL pixel format attribute list
GLint AGLpixelFormatAttributes[256];
int numAGLAttrs = 0;
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_RGBA;
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_DOUBLEBUFFER;
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_CLOSEST_POLICY;
if( fbconfig->stereo )
{
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_STEREO;
}
_setAGLAttribute( AGL_AUX_BUFFERS, fbconfig->auxBuffers);
_setAGLAttribute( AGL_RED_SIZE, fbconfig->redBits );
_setAGLAttribute( AGL_GREEN_SIZE, fbconfig->greenBits );
_setAGLAttribute( AGL_BLUE_SIZE, fbconfig->blueBits );
_setAGLAttribute( AGL_ALPHA_SIZE, fbconfig->alphaBits );
_setAGLAttribute( AGL_DEPTH_SIZE, fbconfig->depthBits );
_setAGLAttribute( AGL_STENCIL_SIZE, fbconfig->stencilBits );
_setAGLAttribute( AGL_ACCUM_RED_SIZE, fbconfig->accumRedBits );
_setAGLAttribute( AGL_ACCUM_GREEN_SIZE, fbconfig->accumGreenBits );
_setAGLAttribute( AGL_ACCUM_BLUE_SIZE, fbconfig->accumBlueBits );
_setAGLAttribute( AGL_ACCUM_ALPHA_SIZE, fbconfig->accumAlphaBits );
if( fbconfig->samples > 1 )
{
_setAGLAttribute( AGL_SAMPLE_BUFFERS_ARB, 1 );
_setAGLAttribute( AGL_SAMPLES_ARB, fbconfig->samples );
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_NO_RECOVERY;
}
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_NONE;
// create pixel format descriptor
AGLDevice mainMonitor = GetMainDevice();
_glfwWin.aglPixelFormat = aglChoosePixelFormat( &mainMonitor,
1,
AGLpixelFormatAttributes );
if( _glfwWin.aglPixelFormat == NULL )
{
fprintf( stderr,
"Failed to choose AGL pixel format: %s\n",
aglErrorString( aglGetError() ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// create AGL context
_glfwWin.aglContext = aglCreateContext( _glfwWin.aglPixelFormat, NULL );
if( _glfwWin.aglContext == NULL )
{
fprintf( stderr,
"Failed to create AGL context: %s\n",
aglErrorString( aglGetError() ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// create window
Rect windowContentBounds;
windowContentBounds.left = 0;
windowContentBounds.top = 0;
windowContentBounds.right = width;
windowContentBounds.bottom = height;
windowAttributes = ( kWindowCloseBoxAttribute |
kWindowCollapseBoxAttribute |
kWindowStandardHandlerAttribute );
if( wndconfig->windowNoResize )
{
windowAttributes |= kWindowLiveResizeAttribute;
}
else
{
windowAttributes |= ( kWindowFullZoomAttribute |
kWindowResizableAttribute );
}
error = CreateNewWindow( kDocumentWindowClass,
windowAttributes,
&windowContentBounds,
&( _glfwWin.window ) );
if( ( error != noErr ) || ( _glfwWin.window == NULL ) )
{
fprintf( stderr, "Failed to create Carbon window\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
_glfwWin.windowUPP = NewEventHandlerUPP( windowEventHandler );
error = InstallWindowEventHandler( _glfwWin.window,
_glfwWin.windowUPP,
GetEventTypeCount( GLFW_WINDOW_EVENT_TYPES ),
GLFW_WINDOW_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "Failed to install Carbon window event handler\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// Don't care if we fail here
(void)SetWindowTitleWithCFString( _glfwWin.window, CFSTR( "GLFW Window" ) );
(void)RepositionWindow( _glfwWin.window,
NULL,
kWindowCenterOnMainScreen );
if( !aglSetDrawable( _glfwWin.aglContext,
GetWindowPort( _glfwWin.window ) ) )
{
fprintf( stderr,
"Failed to set the AGL context as the Carbon window drawable: %s\n",
aglErrorString( aglGetError() ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// Make OpenGL context current
if( !aglSetCurrentContext( _glfwWin.aglContext ) )
{
fprintf( stderr,
"Failed to make AGL context current: %s\n",
aglErrorString( aglGetError() ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
ShowWindow( _glfwWin.window );
}
else
{
CGDisplayErr cgErr;
CGLError cglErr;
CFDictionaryRef optimalMode;
GLint numCGLvs = 0;
CGLPixelFormatAttribute CGLpixelFormatAttributes[64];
int numCGLAttrs = 0;
// variables for enumerating color depths
GLint rgbColorDepth;
// CGL pixel format attributes
_setCGLAttribute( kCGLPFADisplayMask,
CGDisplayIDToOpenGLDisplayMask( kCGDirectMainDisplay ) );
if( fbconfig->stereo )
{
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAStereo;
}
if( fbconfig->samples > 1 )
{
_setCGLAttribute( kCGLPFASamples, (CGLPixelFormatAttribute)fbconfig->samples );
_setCGLAttribute( kCGLPFASampleBuffers, (CGLPixelFormatAttribute)1 );
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFANoRecovery;
}
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAFullScreen;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFADoubleBuffer;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAAccelerated;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFANoRecovery;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAMinimumPolicy;
_setCGLAttribute( kCGLPFAAccumSize,
(CGLPixelFormatAttribute)( fbconfig->accumRedBits \
+ fbconfig->accumGreenBits \
+ fbconfig->accumBlueBits \
+ fbconfig->accumAlphaBits ) );
_setCGLAttribute( kCGLPFAAlphaSize, (CGLPixelFormatAttribute)fbconfig->alphaBits );
_setCGLAttribute( kCGLPFADepthSize, (CGLPixelFormatAttribute)fbconfig->depthBits );
_setCGLAttribute( kCGLPFAStencilSize, (CGLPixelFormatAttribute)fbconfig->stencilBits );
_setCGLAttribute( kCGLPFAAuxBuffers, (CGLPixelFormatAttribute)fbconfig->auxBuffers );
CGLpixelFormatAttributes[ numCGLAttrs++ ] = (CGLPixelFormatAttribute)NULL;
// create a suitable pixel format with above attributes..
cglErr = CGLChoosePixelFormat( CGLpixelFormatAttributes,
&_glfwWin.cglPixelFormat,
&numCGLvs );
if( cglErr != kCGLNoError )
{
fprintf( stderr,
"Failed to choose CGL pixel format: %s\n",
CGLErrorString( cglErr ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// ..and create a rendering context using that pixel format
cglErr = CGLCreateContext( _glfwWin.cglPixelFormat, NULL, &_glfwWin.cglContext );
if( cglErr != kCGLNoError )
{
fprintf( stderr,
"Failed to create CGL context: %s\n",
CGLErrorString( cglErr ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// enumerate depth of RGB channels - unlike AGL, CGL works with
// a single parameter reflecting the full depth of the frame buffer
(void)CGLDescribePixelFormat( _glfwWin.cglPixelFormat,
0,
kCGLPFAColorSize,
&rgbColorDepth );
// capture the display for our application
cgErr = CGCaptureAllDisplays();
if( cgErr != kCGErrorSuccess )
{
fprintf( stderr,
"Failed to capture Core Graphics displays\n");
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// find closest matching NON-STRETCHED display mode..
optimalMode = CGDisplayBestModeForParametersAndRefreshRateWithProperty(
kCGDirectMainDisplay,
rgbColorDepth,
width,
height,
wndconfig->refreshRate,
NULL,
NULL );
if( optimalMode == NULL )
{
fprintf( stderr,
"Failed to retrieve Core Graphics display mode\n");
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// ..and switch to that mode
cgErr = CGDisplaySwitchToMode( kCGDirectMainDisplay, optimalMode );
if( cgErr != kCGErrorSuccess )
{
fprintf( stderr,
"Failed to switch to Core Graphics display mode\n");
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// switch to our OpenGL context, and bring it up fullscreen
cglErr = CGLSetCurrentContext( _glfwWin.cglContext );
if( cglErr != kCGLNoError )
{
fprintf( stderr,
"Failed to make CGL context current: %s\n",
CGLErrorString( cglErr ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
cglErr = CGLSetFullScreen( _glfwWin.cglContext );
if( cglErr != kCGLNoError )
{
fprintf( stderr,
"Failed to set CGL fullscreen mode: %s\n",
CGLErrorString( cglErr ) );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
}
return GL_TRUE;
}
void _glfwPlatformRefreshWindowParams( void )
{
GLint rgbColorDepth;
GLint rgbaAccumDepth = 0;
GLint rgbChannelDepth = 0;
if( _glfwWin.fullscreen )
{
_getCGLAttribute( kCGLPFAAccelerated, _glfwWin.accelerated );
_getCGLAttribute( kCGLPFAAlphaSize, _glfwWin.alphaBits );
_getCGLAttribute( kCGLPFADepthSize, _glfwWin.depthBits );
_getCGLAttribute( kCGLPFAStencilSize, _glfwWin.stencilBits );
_getCGLAttribute( kCGLPFAAuxBuffers, _glfwWin.auxBuffers );
_getCGLAttribute( kCGLPFAStereo, _glfwWin.stereo );
_getCGLAttribute( kCGLPFASamples, _glfwWin.samples );
// Enumerate depth of RGB channels - unlike AGL, CGL works with
// a single parameter reflecting the full depth of the frame buffer
(void)CGLDescribePixelFormat( _glfwWin.cglPixelFormat,
0,
kCGLPFAColorSize,
&rgbColorDepth );
if( rgbColorDepth == 24 || rgbColorDepth == 32 )
{
rgbChannelDepth = 8;
}
if( rgbColorDepth == 16 )
{
rgbChannelDepth = 5;
}
_glfwWin.redBits = rgbChannelDepth;
_glfwWin.greenBits = rgbChannelDepth;
_glfwWin.blueBits = rgbChannelDepth;
// Get pixel depth of accumulator - I haven't got the slightest idea
// how this number conforms to any other channel depth than 8 bits,
// so this might end up giving completely knackered results...
_getCGLAttribute( kCGLPFAColorSize, rgbaAccumDepth );
if( rgbaAccumDepth == 32 )
{
rgbaAccumDepth = 8;
}
_glfwWin.accumRedBits = rgbaAccumDepth;
_glfwWin.accumGreenBits = rgbaAccumDepth;
_glfwWin.accumBlueBits = rgbaAccumDepth;
_glfwWin.accumAlphaBits = rgbaAccumDepth;
}
else
{
_getAGLAttribute( AGL_ACCELERATED, _glfwWin.accelerated );
_getAGLAttribute( AGL_RED_SIZE, _glfwWin.redBits );
_getAGLAttribute( AGL_GREEN_SIZE, _glfwWin.greenBits );
_getAGLAttribute( AGL_BLUE_SIZE, _glfwWin.blueBits );
_getAGLAttribute( AGL_ALPHA_SIZE, _glfwWin.alphaBits );
_getAGLAttribute( AGL_DEPTH_SIZE, _glfwWin.depthBits );
_getAGLAttribute( AGL_STENCIL_SIZE, _glfwWin.stencilBits );
_getAGLAttribute( AGL_ACCUM_RED_SIZE, _glfwWin.accumRedBits );
_getAGLAttribute( AGL_ACCUM_GREEN_SIZE, _glfwWin.accumGreenBits );
_getAGLAttribute( AGL_ACCUM_BLUE_SIZE, _glfwWin.accumBlueBits );
_getAGLAttribute( AGL_ACCUM_ALPHA_SIZE, _glfwWin.accumAlphaBits );
_getAGLAttribute( AGL_AUX_BUFFERS, _glfwWin.auxBuffers );
_getAGLAttribute( AGL_STEREO, _glfwWin.stereo );
_getAGLAttribute( AGL_SAMPLES_ARB, _glfwWin.samples );
}
}
