GLContext* OSXCGLContext::clone() const
{
CGLContextObj cglCtxShare;
CGLCreateContext(mPixelFormat, mCGLContext, &cglCtxShare);
return OGRE_NEW OSXCGLContext(cglCtxShare, mPixelFormat);
}
static void PlatformInitOpenGL(void*& ContextPtr, void*& PrevContextPtr, int InMajorVersion, int InMinorVersion)
{
check(InMajorVersion > 3 || (InMajorVersion == 3 && InMinorVersion >= 2));
CGLPixelFormatAttribute AttribList[] =
{
kCGLPFANoRecovery,
kCGLPFAAccelerated,
kCGLPFAOpenGLProfile,
(CGLPixelFormatAttribute)kCGLOGLPVersion_3_2_Core,
(CGLPixelFormatAttribute)0
};
CGLPixelFormatObj PixelFormat;
GLint NumFormats = 0;
CGLError Error = CGLChoosePixelFormat(AttribList, &PixelFormat, &NumFormats);
check(Error == kCGLNoError);
CGLContextObj ShaderCompileContext;
Error = CGLCreateContext(PixelFormat, NULL, &ShaderCompileContext);
check(Error == kCGLNoError);
Error = CGLDestroyPixelFormat(PixelFormat);
check(Error == kCGLNoError);
PrevContextPtr = (void*)CGLGetCurrentContext();
Error = CGLSetCurrentContext(ShaderCompileContext);
check(Error == kCGLNoError);
ContextPtr = (void*)ShaderCompileContext;
}
bool RTCALL VBoxOglIs3DAccelerationSupported()
{
if (RTEnvGet("VBOX_CROGL_FORCE_SUPPORTED"))
{
LogRel(("VBOX_CROGL_FORCE_SUPPORTED is specified, skipping 3D test, and treating as supported\n"));
return true;
}
CGDirectDisplayID display = CGMainDisplayID ();
CGOpenGLDisplayMask cglDisplayMask = CGDisplayIDToOpenGLDisplayMask (display);
CGLPixelFormatObj pixelFormat = NULL;
GLint numPixelFormats = 0;
CGLPixelFormatAttribute attribs[] = {
kCGLPFADisplayMask,
(CGLPixelFormatAttribute)cglDisplayMask,
kCGLPFAAccelerated,
kCGLPFADoubleBuffer,
kCGLPFAWindow,
(CGLPixelFormatAttribute)NULL
};
display = CGMainDisplayID();
cglDisplayMask = CGDisplayIDToOpenGLDisplayMask(display);
CGLChoosePixelFormat(attribs, &pixelFormat, &numPixelFormats);
if (pixelFormat)
{
CGLContextObj cglContext = 0;
CGLCreateContext(pixelFormat, NULL, &cglContext);
CGLDestroyPixelFormat(pixelFormat);
if (cglContext)
{
GLboolean isSupported = GL_TRUE;
#ifdef VBOX_WITH_COCOA_QT
/* On the Cocoa port we depend on the GL_EXT_framebuffer_object &
* the GL_EXT_texture_rectangle extension. If they are not
* available, disable 3D support. */
CGLSetCurrentContext(cglContext);
const GLubyte* strExt;
strExt = glGetString(GL_EXTENSIONS);
isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_framebuffer_object", strExt);
if (isSupported)
{
isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_texture_rectangle", strExt);
if (!isSupported)
LogRel(("OpenGL Info: GL_EXT_texture_rectangle extension not supported\n"));
}
else
LogRel(("OpenGL Info: GL_EXT_framebuffer_object extension not supported\n"));
#endif /* VBOX_WITH_COCOA_QT */
CGLDestroyContext(cglContext);
return isSupported == GL_TRUE ? true : false;
}
}
return false;
}
static bool setup_gl_context() {
CGLPixelFormatAttribute attributes[] = { (CGLPixelFormatAttribute)0 };
CGLPixelFormatObj format;
GLint npix;
CGLChoosePixelFormat(attributes, &format, &npix);
CGLContextObj context;
CGLCreateContext(format, nullptr, &context);
CGLSetCurrentContext(context);
CGLReleasePixelFormat(format);
return true;
}
Gre::RenderContextHolder DarwinGlRenderer::iCreateRenderContext(const std::string &name, const Gre::RenderContextInfo &info) const
{
if ( iGlobalContext )
{
if ( !name.empty() )
{
// For now, we don't take advantage of the data in 'info' .
CGLContextObj ctxt = nullptr;
if ( CGLCreateContext(iDefaultPixelFormat, iGlobalContext, &ctxt) == kCGLNoError )
{
GreDebugPretty() << "OpenGl Context '" << name << "' created." << std::endl;
Gre::RenderContextHolder holder = Gre::RenderContextHolder ( new DarwinGlContext(name, info, ctxt) );
if ( holder.isInvalid() )
{
GreDebugPretty() << "Can't create 'Gre::RenderContextHolder' Resource." << std::endl;
if ( CGLDestroyContext(ctxt) != kCGLNoError )
{
GreDebugPretty() << "Can't destroy OpenGl Context." << std::endl;
}
return Gre::RenderContextHolder ( nullptr );
}
else
{
return holder;
}
}
else
{
GreDebugPretty() << "OpenGl Context '" << name << "' couldn't be created." << std::endl;
return Gre::RenderContextHolder ( nullptr );
}
}
else
{
GreDebugPretty() << "'name' is invalid." << std::endl;
return Gre::RenderContextHolder ( nullptr );
}
}
else
{
GreDebugPretty() << "'iGlobalContext' has not been initialized." << std::endl;
return Gre::RenderContextHolder ( nullptr );
}
}
/*
* constructor (APPLE specific)
*/
PBuffer::PBuffer(int width, int height, int flag) : width(width), height(height)
{
OSStatus err = noErr;
CGLPixelFormatAttribute *att,attrib[64];
GemCGLint vs, npf;
// setup offscreen context
att=attrib;
*att++=kCGLPFANoRecovery;
*att++=kCGLPFAAccelerated;
*att++=kCGLPFAWindow;
// *att++=kCGLPFAPBuffer;
*att++=kCGLPFAColorSize;
*att++=(CGLPixelFormatAttribute)32;
if (flag & GEM_PBUFLAG_DEPTH){
*att++=kCGLPFADepthSize;
//*att++=(CGLPixelFormatAttribute)24;
*att++=(CGLPixelFormatAttribute)16;
}
if (flag & GEM_PBUFLAG_STENCIL){
*att++=kCGLPFADepthSize;
*att++=(CGLPixelFormatAttribute)8;
}
if (flag & GEM_PBUFLAG_FLOAT){
// *att++=kCGLPFADepthSize;
// *att++=(CGLPixelFormatAttribute)8;
}
//*att++=kCGLPFADoubleBuffer;
// *att++=kCGLPFADisplayMask;
// *att++=kCGLPFAAllRenderers;
*att=(CGLPixelFormatAttribute)0;
data = new PBuffer_data;
data->old_context = CGLGetCurrentContext();
err = CGLGetVirtualScreen(data->old_context, &vs);
verbose (2, "Target Context (0x%X) Renderer: %s\n",data->old_context, glGetString (GL_RENDERER));
cglReportError(CGLChoosePixelFormat (attrib, &data->pixfmt, &npf));
cglReportError(CGLCreateContext (data->pixfmt, data->old_context, &(data->context)));
verbose (2, "pBuffer Context (0x%X) Renderer: %s\n",data->context, glGetString (GL_RENDERER));
/* if (float_buffer)
cglReportError( CGLCreatePBuffer ( width, height, GL_TEXTURE_2D, GL_FLOAT, 0, &(data->pbuffer) ) );
else
*/
cglReportError( CGLCreatePBuffer ( width, height, GL_TEXTURE_RECTANGLE_EXT, GL_RGBA, 0, &(data->pbuffer) ));
cglReportError( CGLSetCurrentContext( data->context ) );
cglReportError( CGLGetVirtualScreen(data->old_context, &vs) );
cglReportError( CGLSetPBuffer(data->context, data->pbuffer, 0, 0, vs) );
verbose (2, "pbuffer (0x%X) Renderer: %s\n",data->pbuffer, glGetString (GL_RENDERER));
}
gl_context_t makeSharedGLContext(gl_context_t shareWith, char const **outError)
{
CGLContextObj shareContext = (CGLContextObj)shareWith;
CGLPixelFormatObj pixelFormat = CGLGetPixelFormat(shareContext);
CGLContextObj newContext;
CGLError code = CGLCreateContext(pixelFormat, shareContext, &newContext);
if (code != kCGLNoError) {
*outError = CGLErrorString(code);
return 0;
} else
return (gl_context_t)newContext;
}
BOOL GL3OSXRenderWindow::InitializeOpenGL()
{
//
CGLPixelFormatAttribute attributes[] =
{
//From : OpenGL Programming Guide for Apple's Mac
//kCGLOGLPVersion_Legacy (OSX 10.7) choose a renderer compatible with OpenGL1.0
//kCGLOGLPVersion_GL3_Core (OSX 10.7) choose a renderer capable of OpenGL3.2 or later
//kCGLOGLPVersion_GL4_Core (OSX 10.9) choose a renderer capable of OpenGL4.1 or later
kCGLPFAOpenGLProfile, (CGLPixelFormatAttribute)kCGLOGLPVersion_GL3_Core,
kCGLPFAColorSize, (CGLPixelFormatAttribute)32,
kCGLPFAAlphaSize, (CGLPixelFormatAttribute)8,
kCGLPFADepthSize, (CGLPixelFormatAttribute)16,
kCGLPFAStencilSize, (CGLPixelFormatAttribute)8,
kCGLPFAAccelerated,
kCGLPFADoubleBuffer,
(CGLPixelFormatAttribute)0
};
//
GLint nPixelFormatNum = 0;
m_pPixelFormatObj = NULL;
CGLError result = CGLChoosePixelFormat(attributes, &m_pPixelFormatObj, &nPixelFormatNum);
if (result != kCGLNoError || m_pPixelFormatObj == NULL)
{
LogManager::getSingletonPtr()->LogMessage(LML_NORMAL, false, _T("<%s> CGLChoosePixelFormat fail [ERROR %d]"),
StringAToStringT(__FUNCTION__).c_str(), result);
return FALSE;
}
m_pContextObj = NULL;
result = CGLCreateContext(m_pPixelFormatObj, NULL, &m_pContextObj);
if (result != kCGLNoError || m_pContextObj == NULL)
{
LogManager::getSingletonPtr()->LogMessage(LML_NORMAL, false, _T("<%s> CGLCreateContext fail [ERROR %d]"),
StringAToStringT(__FUNCTION__).c_str(), result);
return FALSE;
}
//
result = CGLSetCurrentContext(m_pContextObj);
if (result != kCGLNoError)
{
LogManager::getSingletonPtr()->LogMessage(LML_NORMAL, false, _T("<%s> CGLSetCurrentContext fail [ERROR %d]"),
StringAToStringT(__FUNCTION__).c_str(), result);
return FALSE;
}
return TRUE;
}
void macosx_opengl_init(void) {
CGLPixelFormatObj pixelFormatObj;
GLint numPixelFormats;
CGLPixelFormatAttribute attribs[] = {
kCGLPFAFullScreen,
kCGLPFADisplayMask,
0,
0
};
if (macosx_no_opengl) {
return;
}
attribs[2] = CGDisplayIDToOpenGLDisplayMask(displayID);
CGLChoosePixelFormat(attribs, &pixelFormatObj, &numPixelFormats);
if (pixelFormatObj == NULL) {
rfbLog("macosx_opengl_init: CGLChoosePixelFormat failed. Not using OpenGL.\n");
return;
}
CGLCreateContext(pixelFormatObj, NULL, &glContextObj);
CGLDestroyPixelFormat(pixelFormatObj);
if (glContextObj == NULL) {
rfbLog("macosx_opengl_init: CGLCreateContext failed. Not using OpenGL.\n");
return;
}
CGLSetCurrentContext(glContextObj);
CGLSetFullScreen(glContextObj);
macosx_opengl_width = macosx_opengl_get_width();
macosx_opengl_height = macosx_opengl_get_height();
macosx_opengl_bpp = macosx_opengl_get_bpp();
glFinish();
glPixelStorei(GL_PACK_ALIGNMENT, 4);
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
rfbLog("macosx_opengl_init: Using OpenGL for screen capture.\n");
macosx_read_opengl = 1;
}
bool WindowlessCglApplication::tryCreateContext(const Configuration&) {
CORRADE_ASSERT(!_context, "Platform::WindowlessCglApplication::tryCreateContext(): context already created", false);
int formatCount;
CGLPixelFormatAttribute attributes32[] = {
kCGLPFAAccelerated,
kCGLPFAOpenGLProfile,
CGLPixelFormatAttribute(kCGLOGLPVersion_3_2_Core),
CGLPixelFormatAttribute(0)
};
if(CGLChoosePixelFormat(attributes32, &_pixelFormat, &formatCount) != kCGLNoError) {
Error() << "Platform::WindowlessCglApplication::tryCreateContext(): cannot choose pixel format for GL 3.2, falling back to 3.0";
CGLPixelFormatAttribute attributes30[] = {
kCGLPFAAccelerated,
kCGLPFAOpenGLProfile,
CGLPixelFormatAttribute(kCGLOGLPVersion_GL3_Core),
CGLPixelFormatAttribute(0)
};
if(CGLChoosePixelFormat(attributes30, &_pixelFormat, &formatCount) != kCGLNoError) {
Error() << "Platform::WindowlessCglApplication::tryCreateContext(): cannot choose pixel format for GL 3.0, falling back to 2.1";
CGLPixelFormatAttribute attributes21[] = {
kCGLPFAAccelerated,
kCGLPFAOpenGLProfile,
CGLPixelFormatAttribute(kCGLOGLPVersion_Legacy),
CGLPixelFormatAttribute(0)
};
if(CGLChoosePixelFormat(attributes21, &_pixelFormat, &formatCount) != kCGLNoError) {
Error() << "Platform::WindowlessCglApplication::tryCreateContext(): cannot choose pixel format";
return false;
}
}
}
if(CGLCreateContext(_pixelFormat, nullptr, &_glContext) != kCGLNoError) {
Error() << "Platform::WindowlessCglApplication::tryCreateContext(): cannot create context";
return false;
}
if(CGLSetCurrentContext(_glContext) != kCGLNoError) {
Error() << "Platform::WindowlessCglApplication::tryCreateContext(): cannot make context current";
return false;
}
_context.reset(new Platform::Context);
return true;
}
void HeadlessView::createContext() {
if (!display) {
throw std::runtime_error("Display is not set");
}
#if MBGL_USE_CGL
CGLError error = CGLCreateContext(display->pixelFormat, NULL, &glContext);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Error creating GL context object:") + CGLErrorString(error) + "\n");
}
error = CGLEnable(glContext, kCGLCEMPEngine);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Error enabling OpenGL multithreading:") + CGLErrorString(error) + "\n");
}
#endif
#if MBGL_USE_GLX
xDisplay = display->xDisplay;
fbConfigs = display->fbConfigs;
if (!glContext) {
// Try to create a legacy context
glContext = glXCreateNewContext(xDisplay, fbConfigs[0], GLX_RGBA_TYPE, None, True);
if (glContext) {
if (!glXIsDirect(xDisplay, glContext)) {
Log::Error(Event::OpenGL, "failed to create direct OpenGL Legacy context");
glXDestroyContext(xDisplay, glContext);
glContext = 0;
}
}
}
if (glContext == 0) {
throw std::runtime_error("Error creating GL context object.");
}
// Create a dummy pbuffer. We will render to framebuffers anyway, but we need a pbuffer to
// activate the context.
int pbufferAttributes[] = {
GLX_PBUFFER_WIDTH, 8,
GLX_PBUFFER_HEIGHT, 8,
None
};
glxPbuffer = glXCreatePbuffer(xDisplay, fbConfigs[0], pbufferAttributes);
#endif
}
int
main (void)
{
CGLPixelFormatAttribute attribs[] = {0};
CGLPixelFormatObj pix;
CGLContextObj ctx;
const char *string;
bool pass = true;
int npix;
GLint shader;
CGLChoosePixelFormat(attribs, &pix, &npix);
CGLCreateContext(pix, (void *) 0, &ctx);
CGLSetCurrentContext(ctx);
if (!epoxy_is_desktop_gl()) {
fputs("Claimed not to be desktop\n", stderr);
pass = false;
}
if (epoxy_gl_version() < 20) {
fprintf(stderr, "Claimed to be GL version %d\n",
epoxy_gl_version());
pass = false;
}
if (epoxy_glsl_version() < 100) {
fprintf(stderr, "Claimed to have GLSL version %d\n",
epoxy_glsl_version());
pass = false;
}
string = (const char *)glGetString(GL_VERSION);
printf("GL version: %s - Epoxy: %d\n", string, epoxy_gl_version());
string = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
printf("GLSL version: %s - Epoxy: %d\n", string, epoxy_glsl_version());
shader = glCreateShader(GL_FRAGMENT_SHADER);
pass = glIsShader(shader);
CGLSetCurrentContext(NULL);
CGLReleaseContext(ctx);
CGLReleasePixelFormat(pix);
return pass != true;
}
static GLboolean CreateContext(GLContext* ctx)
{
CGLPixelFormatAttribute attrib[] = { kCGLPFAAccelerated, 0 };
CGLPixelFormatObj pf;
GLint npix;
CGLError error;
/* check input */
if (NULL == ctx) return GL_TRUE;
error = CGLChoosePixelFormat(attrib, &pf, &npix);
if (error) return GL_TRUE;
error = CGLCreateContext(pf, NULL, &ctx->ctx);
if (error) return GL_TRUE;
CGLReleasePixelFormat(pf);
ctx->octx = CGLGetCurrentContext();
error = CGLSetCurrentContext(ctx->ctx);
if (error) return GL_TRUE;
return GL_FALSE;
}
void HeadlessBackend::createContext() {
assert(!hasContext());
CGLContextObj glContext = nullptr;
CGLError error = CGLCreateContext(display->attribute<CGLPixelFormatObj>(), nullptr, &glContext);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Error creating GL context object:") +
CGLErrorString(error) + "\n");
}
error = CGLEnable(glContext, kCGLCEMPEngine);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Error enabling OpenGL multithreading:") +
CGLErrorString(error) + "\n");
}
impl.reset(new CGLImpl(glContext));
}
static CGLContextObj gfx_ctx_cgl_init_create(void)
{
GLint num, params = 1;
CGLPixelFormatObj pix;
CGLContextObj glCtx = NULL;
CGLPixelFormatAttribute attributes[] = {
kCGLPFAAccelerated,
kCGLPFADoubleBuffer,
(CGLPixelFormatAttribute)0
};
CGLChoosePixelFormat(attributes, &pix, &num);
CGLCreateContext(pix, NULL, &glCtx);
CGLDestroyPixelFormat(pix);
CGLSetParameter(glCtx, kCGLCPSwapInterval, ¶ms);
return glCtx;
}
static CGLError test_gl_version(struct vo *vo,
CGLContextObj *ctx,
CGLPixelFormatObj *pix,
CGLOpenGLProfile version)
{
CGLPixelFormatAttribute attrs[] = {
kCGLPFAOpenGLProfile,
(CGLPixelFormatAttribute) version,
kCGLPFADoubleBuffer,
kCGLPFAAccelerated,
#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_8
// leave this as the last entry of the array to not break the fallback
// code
kCGLPFASupportsAutomaticGraphicsSwitching,
#endif
0
};
GLint npix;
CGLError err;
err = CGLChoosePixelFormat(attrs, pix, &npix);
if (err == kCGLBadAttribute) {
// kCGLPFASupportsAutomaticGraphicsSwitching is probably not supported
// by the current hardware. Falling back to not using it.
attrs[MP_ARRAY_SIZE(attrs) - 2] = 0;
err = CGLChoosePixelFormat(attrs, pix, &npix);
}
if (err != kCGLNoError) {
MP_ERR(vo, "error creating CGL pixel format: %s (%d)\n",
CGLErrorString(err), err);
goto error_out;
}
err = CGLCreateContext(*pix, 0, ctx);
error_out:
return err;
}
int createTestGLContext(void) {
CGLPixelFormatAttribute attributes[] = {
kCGLPFAOpenGLProfile, kCGLOGLPVersion_3_2_Core,
kCGLPFADoubleBuffer,
0
};
CGLPixelFormatObj pixelFormat;
GLint numScreens;
CGLError error;
error = CGLChoosePixelFormat(attributes, &pixelFormat, &numScreens);
if (error != kCGLNoError)
return 0;
error = CGLCreateContext(pixelFormat, 0, &g_context);
CGLReleasePixelFormat(pixelFormat);
if (error != kCGLNoError)
return 0;
CGLSetCurrentContext(g_context);
return 1;
}
GLboolean glewCreateContext (struct createParams *params)
{
CGLPixelFormatAttribute contextAttrs[20];
int i;
CGLPixelFormatObj pf;
GLint npix;
CGLError error;
i = 0;
contextAttrs[i++] = kCGLPFAAccelerated; /* No software rendering */
#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_7
if (params->profile & GL_CONTEXT_CORE_PROFILE_BIT)
{
if (params->major==3 && params->minor>=2)
{
contextAttrs[i++] = kCGLPFAOpenGLProfile; /* OSX 10.7 Lion onwards */
contextAttrs[i++] = (CGLPixelFormatAttribute) kCGLOGLPVersion_3_2_Core; /* 3.2 Core Context */
}
}
#endif
contextAttrs[i++] = 0;
error = CGLChoosePixelFormat(contextAttrs, &pf, &npix);
if (error) return GL_TRUE;
error = CGLCreateContext(pf, NULL, &ctx);
if (error) return GL_TRUE;
CGLReleasePixelFormat(pf);
octx = CGLGetCurrentContext();
error = CGLSetCurrentContext(ctx);
if (error) return GL_TRUE;
/* Needed for Regal on the Mac */
#if defined(GLEW_REGAL) && defined(__APPLE__)
RegalMakeCurrent(ctx);
#endif
return GL_FALSE;
}
COffscreenGLContext::COffscreenGLContext()
{
// Get Current OnScreen Context
CGLContextObj currentCglCtx = CGLGetCurrentContext();
if (!currentCglCtx)
throw opengl_error("Couldn't create an offscreen GL context: CGLGetCurrentContext failed!");
// Get PixelFormat
CGLPixelFormatAttribute attribs[] = {
(CGLPixelFormatAttribute)0
};
GLint numPixelFormats = 0;
CGLPixelFormatObj cglPxlfmt = NULL;
CGLChoosePixelFormat(attribs, &cglPxlfmt, &numPixelFormats);
if (!cglPxlfmt)
throw opengl_error("Couldn't create an offscreen GL context: CGLChoosePixelFmt failed!");
// Create Shared Context
CGLCreateContext(cglPxlfmt, currentCglCtx, &cglWorkerCtx);
CGLDestroyPixelFormat(cglPxlfmt);
if (!cglWorkerCtx)
throw opengl_error("Couldn't create an offscreen GL context: CGLCreateContext failed!");
}
void GLContext::create( const GLContext *share )
{
if ( context != NULL ) return;
save_context = CGLGetCurrentContext();
CGLPixelFormatAttribute attribs[] = {
kCGLPFANoRecovery,
kCGLPFADoubleBuffer,
kCGLPFAAccelerated,
kCGLPFAColorSize, (CGLPixelFormatAttribute)24,
kCGLPFADepthSize, (CGLPixelFormatAttribute)24,
(CGLPixelFormatAttribute)0
};
CGLPixelFormatObj pix;
GLint npix;
CGLChoosePixelFormat(attribs, &pix, &npix );
CGLContextObj share_context = NULL;
if ( share != NULL ) share_context = share->context;
CGLCreateContext( pix, share_context, &context );
}
/* Creates and returns a full-screen OpenGL graphics context (to be
* released/destroyed by caller).
*
* To clean up the returned context use destroyFullScreenCGLContext(); */
static CGLContextObj createFullScreenCGLContext(CGOpenGLDisplayMask displayMask)
{
CGLContextObj glContext = NULL;
CGLPixelFormatObj pix;
GLint npix;
CGLPixelFormatAttribute attribs[4];
attribs[0] = kCGLPFAFullScreen;
attribs[1] = kCGLPFADisplayMask;
attribs[2] = displayMask;
attribs[3] = (CGLPixelFormatAttribute)0;
CGLChoosePixelFormat(attribs, &pix, &npix);
CGLCreateContext(pix, NULL, &glContext);
/* The pixel format is no longer needed, so destroy it. */
CGLDestroyPixelFormat(pix);
if (glContext == NULL) return NULL;
/* Set our context as the current OpenGL context. */
CGLSetCurrentContext(glContext);
/* Set full-screen mode. */
CGLSetFullScreen(glContext);
//CGLSetFullScreenOnDisplay(glContext, displayMask);
/* Select front buffer as our source for pixel data. */
glReadBuffer(GL_FRONT);
/* Finish previous OpenGL commands before continuing. */
glFinish();
if (glGetError() != GL_NO_ERROR) return NULL;
return glContext;
}
CGLError screen_CreateContext( CGLContextObj *context,
CGLPixelFormatAttribute a0,
CGLPixelFormatAttribute a1,
CGLPixelFormatAttribute a2,
CGLPixelFormatAttribute a3 )
{
CGLPixelFormatAttribute attribs[4];
CGLPixelFormatObj pix;
GLint npix;
CGLError returnedError;
attribs[0] = a0;
attribs[1] = a1;
attribs[2] = a2;
attribs[3] = a3;
returnedError = CGLChoosePixelFormat( attribs, &pix, &npix );
if( returnedError )
{
return returnedError;
}
returnedError = CGLCreateContext( pix, NULL, context );
if( returnedError )
{
return returnedError;
}
returnedError = CGLDestroyPixelFormat( pix );
if( returnedError )
{
return returnedError;
}
return kCGLNoError;
}
screenshot* capture() {
CGContextRef bitmap;
CGImageRef image;
void * data;
long bytewidth;
GLint width, height;
long bytes;
CGColorSpaceRef cSpace = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB);
CGLContextObj glContextObj;
CGLPixelFormatObj pixelFormatObj ;
long numPixelFormats ;
CGLPixelFormatAttribute attribs[] =
{
kCGLPFAFullScreen,
kCGLPFADisplayMask,
0, /* Display mask bit goes here */
0
} ;
if ( display == kCGNullDirectDisplay )
display = CGMainDisplayID();
attribs[2] = CGDisplayIDToOpenGLDisplayMask(display);
/* Build a full-screen GL context */
CGLChoosePixelFormat( attribs, &pixelFormatObj, &numPixelFormats );
if ( pixelFormatObj == NULL ) // No full screen context support
return NULL;
CGLCreateContext( pixelFormatObj, NULL, &glContextObj ) ;
CGLDestroyPixelFormat( pixelFormatObj ) ;
if ( glContextObj == NULL )
return NULL;
CGLSetCurrentContext( glContextObj ) ;
CGLSetFullScreen( glContextObj ) ;
glReadBuffer(GL_FRONT);
width = srcRect.size.width;
height = srcRect.size.height;
bytewidth = width * 4; // Assume 4 bytes/pixel for now
bytewidth = (bytewidth + 3) & ~3; // Align to 4 bytes
bytes = bytewidth * height; // width * height
/* Build bitmap context */
data = malloc(height * bytewidth);
if ( data == NULL )
{
CGLSetCurrentContext( NULL );
CGLClearDrawable( glContextObj ); // disassociate from full screen
CGLDestroyContext( glContextObj ); // and destroy the context
return NULL;
}
bitmap = CGBitmapContextCreate(data, width, height, 8, bytewidth,
cSpace, kCGImageAlphaNoneSkipFirst /* XRGB */);
CFRelease(cSpace);
/* Read framebuffer into our bitmap */
glFinish(); /* Finish all OpenGL commands */
glPixelStorei(GL_PACK_ALIGNMENT, 4); /* Force 4-byte alignment */
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
/*
* Fetch the data in XRGB format, matching the bitmap context.
*/
glReadPixels(
(GLint) srcRect.origin.x,
(GLint)srcRect.origin.y,
width,
height,
GL_BGRA,
#ifdef __BIG_ENDIAN__
GL_UNSIGNED_INT_8_8_8_8_REV, // for PPC
#else
GL_UNSIGNED_INT_8_8_8_8, // for Intel! http://lists.apple.com/archives/quartz-dev/2006/May/msg00100.html
#endif
data);
/*
* glReadPixels generates a quadrant I raster, with origin in the lower left
* This isn't a problem for signal processing routines such as compressors,
* as they can simply use a negative 'advance' to move between scanlines.
* CGImageRef and CGBitmapContext assume a quadrant III raster, though, so we need to
* invert it. Pixel reformatting can also be done here.
*/
swizzleBitmap(data, bytewidth, height);
/* Make an image out of our bitmap; does a cheap vm_copy of the bitmap */
image = CGBitmapContextCreateImage(bitmap);
/* Get rid of bitmap */
CFRelease(bitmap);
free(data);
/* Get rid of GL context */
CGLSetCurrentContext( NULL );
CGLClearDrawable( glContextObj ); // disassociate from full screen
CGLDestroyContext( glContextObj ); // and destroy the context
/* Returned image has a reference count of 1 */
return image;
}
//-----------------------------------------------------------------------------
// utilities
//-----------------------------------------------------------------------------
bool DoGLSection(Environment &env, Signal &sig, Argument &arg, Image *pImage)
{
#if GURA_USE_MSWIN_DIB
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), 1,
PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL, PFD_TYPE_RGBA,
static_cast<BYTE>(pImage->GetBitsPerPixel()), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
32, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
};
HDC hdc = ::CreateCompatibleDC(nullptr);
HBITMAP hBmp = pImage->GetHBITMAP();
HBITMAP hBmpOld = reinterpret_cast<HBITMAP>(::SelectObject(hdc, hBmp));
int iPixelFormat = ::ChoosePixelFormat(hdc, &pfd);
::SetPixelFormat(hdc, iPixelFormat, &pfd);
HGLRC hglrc = ::wglCreateContext(hdc);
::wglMakeCurrent(hdc, hglrc);
const Expr_Block *pExprBlock = arg.GetBlockCooked(env);
if (!sig.IsSignalled()) {
pExprBlock->Exec(env);
}
::wglMakeCurrent(nullptr, nullptr);
::wglDeleteContext(hglrc);
::SelectObject(hdc, hBmpOld);
::DeleteDC(hdc);
return true;
#elif defined(GURA_ON_DARWIN)
//*****************
// not working yet.
//*****************
GLsizei width = static_cast<GLsizei>(pImage->GetWidth());
GLsizei height = static_cast<GLsizei>(pImage->GetHeight());
CGLError errCode = kCGLNoError;
GLuint texOut = 0;
CGLContextObj ctx = nullptr;
CGLContextObj ctxOrg = CGLGetCurrentContext();
CGLPixelFormatAttribute attributes[4] = {
kCGLPFAAccelerated,
kCGLPFAOpenGLProfile,
(CGLPixelFormatAttribute)kCGLOGLPVersion_3_2_Core,
(CGLPixelFormatAttribute)0
};
CGLPixelFormatObj pixelFormat = nullptr;
GLint numPixelFormats = 0;
errCode = CGLChoosePixelFormat(attributes, &pixelFormat, &numPixelFormats);
errCode = CGLCreateContext(pixelFormat, nullptr, &ctx);
errCode = CGLSetCurrentContext(ctx);
glGenTextures(1, &texOut);
glBindTexture(GL_TEXTURE_2D, texOut);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
GLuint frameBuffer = 0;
glGenFramebuffers(1, &frameBuffer);
glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texOut, 0);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status == GL_FRAMEBUFFER_COMPLETE) {
const Expr_Block *pExprBlock = arg.GetBlockCooked(env);
if (!sig.IsSignalled()) {
pExprBlock->Exec(env);
}
}
do {
GLenum format = GetImageFormat(env, pImage);
if (sig.IsSignalled()) return false;
glBindTexture(GL_TEXTURE_2D, texOut);
glGetTexImage(GL_TEXTURE_2D, 0, format, GL_UNSIGNED_BYTE, pImage->GetBuffer());
} while (0);
glDeleteTextures(1, &texOut);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
CGLSetCurrentContext(ctxOrg);
CGLDestroyContext(ctx);
return true;
#else
#if 0
int width = static_cast<int>(pImage->GetWidth());
int height = static_cast<int>(pImage->GetHeight());
GLXFBConfig config;
Pixmap pixmap = ::XCreatePixmap(nullptr, d, width, height, 32);
GLXPixmap xid = ::glXCreatePixmap(nullptr, config, pixmap, nullptr);
GLXContext ctx;
::glXMakeCurrent(nullptr, xid, ctx);
const Expr_Block *pExprBlock = arg.GetBlockCooked(env);
if (!sig.IsSignalled()) {
pExprBlock->Exec(env);
}
::glReadPixels(0, 0, width, height, GL_BGRA_EXT,
GL_UNSIGNED_BYTE, pImage->GetBuffer());
#endif
#endif
return true;
}
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext, const IntSize& size, GraphicsSurface::Flags flags)
: m_context(0)
, m_size(size)
, m_frontBufferTexture(0)
, m_frontBufferReadTexture(0)
, m_backBufferTexture(0)
, m_backBufferReadTexture(0)
, m_readFbo(0)
, m_drawFbo(0)
{
#if PLATFORM(QT)
QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface();
CGLContextObj shareContextObject = static_cast<CGLContextObj>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("cglContextObj"), shareContext));
if (!shareContextObject)
return;
CGLPixelFormatObj pixelFormatObject = CGLGetPixelFormat(shareContextObject);
if (kCGLNoError != CGLCreateContext(pixelFormatObject, shareContextObject, &m_context))
return;
CGLRetainContext(m_context);
#endif
unsigned pixelFormat = 'BGRA';
unsigned bytesPerElement = 4;
int width = m_size.width();
int height = m_size.height();
unsigned long bytesPerRow = IOSurfaceAlignProperty(kIOSurfaceBytesPerRow, width * bytesPerElement);
if (!bytesPerRow)
return;
unsigned long allocSize = IOSurfaceAlignProperty(kIOSurfaceAllocSize, height * bytesPerRow);
if (!allocSize)
return;
const void *keys[6];
const void *values[6];
keys[0] = kIOSurfaceWidth;
values[0] = CFNumberCreate(0, kCFNumberIntType, &width);
keys[1] = kIOSurfaceHeight;
values[1] = CFNumberCreate(0, kCFNumberIntType, &height);
keys[2] = kIOSurfacePixelFormat;
values[2] = CFNumberCreate(0, kCFNumberIntType, &pixelFormat);
keys[3] = kIOSurfaceBytesPerElement;
values[3] = CFNumberCreate(0, kCFNumberIntType, &bytesPerElement);
keys[4] = kIOSurfaceBytesPerRow;
values[4] = CFNumberCreate(0, kCFNumberLongType, &bytesPerRow);
keys[5] = kIOSurfaceAllocSize;
values[5] = CFNumberCreate(0, kCFNumberLongType, &allocSize);
CFDictionaryRef dict = CFDictionaryCreate(0, keys, values, 6, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
for (unsigned i = 0; i < 6; i++)
CFRelease(values[i]);
m_frontBuffer = IOSurfaceCreate(dict);
m_backBuffer = IOSurfaceCreate(dict);
if (!(flags & GraphicsSurface::SupportsSharing))
return;
m_token = GraphicsSurfaceToken(IOSurfaceCreateMachPort(m_frontBuffer), IOSurfaceCreateMachPort(m_backBuffer));
}
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;
}
}
static int
setup(int width, int height)
{
#if USE_OSMESA
const size_t size = width * height * 4;
pbuffer = malloc(size);
memset(pbuffer, 0x21, size);
context = OSMesaCreateContextExt(GL_RGBA, 24, 0, 0, 0);
OSMesaMakeCurrent(context, (void *)pbuffer, GL_UNSIGNED_BYTE, width, height);
return 0;
#elif USE_CGL
/* OpenGL PBuffer initialization: OSX specific */
CGLPixelFormatAttribute pfattr[] = {
kCGLPFAPBuffer,
(CGLPixelFormatAttribute)0
};
CGLPixelFormatObj pixformat;
GLint npixels;
int e;
e = CGLChoosePixelFormat(pfattr, &pixformat, &npixels);
if (e != kCGLNoError) {
fprintf(stderr, "CGLChoosePixelFormat failed, err %d\n", e);
return e;
}
e = CGLCreateContext(pixformat, 0, &context);
if (e != kCGLNoError) {
fprintf(stderr, "CGLChoosePixelFormat failed, err %d\n", e);
return e;
}
e = CGLDestroyPixelFormat(pixformat);
if (e != kCGLNoError) {
fprintf(stderr, "CGLDestroyPixelFormat failed, err %d\n", e);
return e;
}
e = CGLSetCurrentContext(context);
if (e != kCGLNoError) {
fprintf(stderr, "CGLSetCurrentContext failed, err %d\n", e);
return e;
}
e = CGLCreatePBuffer(width, height, GL_TEXTURE_2D, GL_RGB, 0, &pbuffer);
if (e != kCGLNoError) {
fprintf(stderr, "CGLCreatePBuffer failed, err %d\n", e);
return e;
}
e = CGLSetPBuffer(context, pbuffer, 0, 0, 0);
if (e != kCGLNoError) {
fprintf(stderr, "CGLSetPBuffer failed, err %d\n", e);
return e;
}
return (int)kCGLNoError;
#elif USE_GLX
int result = (-1);
char *glxversion;
int screen;
GLXFBConfig *fbConfigs = NULL;
GLXFBConfig chosenFBConfig;
GLXFBConfig fbconfig = 0;
GLXPbuffer pbuffer = None;
int nConfigs;
int fbconfigid;
int fbAttribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DEPTH_SIZE, 1,
GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT | GLX_PBUFFER_BIT,
None
};
int pbAttribs[] = {
GLX_PBUFFER_WIDTH, 0,
GLX_PBUFFER_HEIGHT, 0,
GLX_LARGEST_PBUFFER, False,
GLX_PRESERVED_CONTENTS, False,
None
};
/* Open the X display */
display = XOpenDisplay(NULL);
if (!display) {
fprintf(stderr, "Error: couldn't open default X display.\n");
goto end;
}
/* Get default screen */
screen = DefaultScreen(display);
glxversion = (char *) glXGetClientString(display, GLX_VERSION);
if (!(strstr(glxversion, "1.3") || strstr(glxversion, "1.4"))) {
goto end;
}
glxversion = (char *) glXQueryServerString(display, screen, GLX_VERSION);
if (!(strstr(glxversion, "1.3") || strstr(glxversion, "1.4"))) {
goto end;
}
/* Create Pbuffer */
pbAttribs[1] = width;
pbAttribs[3] = height;
fbConfigs = glXChooseFBConfig(display, screen, fbAttribs, &nConfigs);
if (0 == nConfigs || !fbConfigs) {
fprintf(stderr, "Error: glxChooseFBConfig failed\n");
XFree(fbConfigs);
goto end;
}
chosenFBConfig = fbConfigs[0];
glXGetFBConfigAttrib(display, chosenFBConfig, GLX_FBCONFIG_ID, &fbconfigid);
/* Create the pbuffer using first fbConfig in the list that works. */
pbuffer = glXCreatePbuffer(display, chosenFBConfig, pbAttribs);
if (pbuffer) {
fbconfig = chosenFBConfig;
}
XFree(fbConfigs);
if (pbuffer == None) {
fprintf(stderr, "Error: couldn't create pbuffer\n");
goto end;
}
/* Create GLX context */
context = glXCreateNewContext(display, fbconfig, GLX_RGBA_TYPE, NULL, True);
if (!context) {
fprintf(stderr, "Error: Couldn't create GLXContext\n");
goto end;
}
/* Bind context to pbuffer */
if (!glXMakeCurrent(display, pbuffer, context)) {
fprintf(stderr, "Error: glXMakeCurrent failed\n");
goto end;
}
result = 0;
end:
if (fbConfigs)
XFree(fbConfigs);
if (display)
XCloseDisplay(display);
return result;
#else
/* TODO: pbuffer initialization */
return 0;
#endif
}
bool RTCALL VBoxOglIs3DAccelerationSupported()
{
if (RTEnvExist("VBOX_CROGL_FORCE_SUPPORTED"))
{
LogRel(("VBOX_CROGL_FORCE_SUPPORTED is specified, skipping 3D test, and treating as supported\n"));
return true;
}
CGDirectDisplayID display = CGMainDisplayID ();
CGOpenGLDisplayMask cglDisplayMask = CGDisplayIDToOpenGLDisplayMask (display);
CGLPixelFormatObj pixelFormat = NULL;
GLint numPixelFormats = 0;
CGLError rcCgl;
CGLPixelFormatAttribute attribs[] = {
kCGLPFADisplayMask,
(CGLPixelFormatAttribute)cglDisplayMask,
kCGLPFAAccelerated,
kCGLPFADoubleBuffer,
VBoxOglIsOfflineRenderingAppropriate() ? kCGLPFAAllowOfflineRenderers : (CGLPixelFormatAttribute)NULL,
(CGLPixelFormatAttribute)NULL
};
display = CGMainDisplayID();
cglDisplayMask = CGDisplayIDToOpenGLDisplayMask(display);
rcCgl = CGLChoosePixelFormat(attribs, &pixelFormat, &numPixelFormats);
if (rcCgl != kCGLNoError)
{
LogRel(("OpenGL Info: 3D test unable to choose pixel format (rcCgl=0x%X)\n", rcCgl));
return false;
}
if (pixelFormat)
{
CGLContextObj cglContext = 0;
rcCgl = CGLCreateContext(pixelFormat, NULL, &cglContext);
CGLDestroyPixelFormat(pixelFormat);
if (rcCgl != kCGLNoError)
{
LogRel(("OpenGL Info: 3D test unable to create context (rcCgl=0x%X)\n", rcCgl));
return false;
}
if (cglContext)
{
GLboolean isSupported = GL_TRUE;
#ifdef VBOX_WITH_COCOA_QT
/* On the Cocoa port we depend on the GL_EXT_framebuffer_object &
* the GL_EXT_texture_rectangle extension. If they are not
* available, disable 3D support. */
CGLSetCurrentContext(cglContext);
const GLubyte* strExt;
strExt = glGetString(GL_EXTENSIONS);
isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_framebuffer_object", strExt);
if (isSupported)
{
isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_texture_rectangle", strExt);
if (!isSupported)
LogRel(("OpenGL Info: 3D test found that GL_EXT_texture_rectangle extension not supported\n"));
}
else
LogRel(("OpenGL Info: 3D test found that GL_EXT_framebuffer_object extension not supported\n"));
#endif /* VBOX_WITH_COCOA_QT */
CGLDestroyContext(cglContext);
LogRel(("OpenGL Info: 3D test %spassed\n", isSupported == GL_TRUE ? "" : "not "));
return isSupported == GL_TRUE ? true : false;
}
else
LogRel(("OpenGL Info: 3D test unable to create context (internal error)\n"));
}
else
LogRel(("OpenGL Info: 3D test unable to choose pixel format (internal error)\n"));
return false;
}
void CheckOpenGLCaps (CGDisplayCount maxDspys,
GLCaps dCaps[],
CGDisplayCount * dCnt)
{
CGLContextObj curr_ctx = 0;
CGDirectDisplayID dspys[32];
CGDisplayErr theErr;
short i;
short size = sizeof (GLCaps);
// no devices
*dCnt = 0;
if (maxDspys == 0) { // find number of displays
*dCnt = 0;
theErr = CGGetActiveDisplayList (32, dspys, dCnt);
if (theErr) // theErr getting list
*dCnt = 0; // 0 displays since can't correctly find any
// zero list to ensure the routines are used correctly
memset (dspys, 0, sizeof (CGDirectDisplayID) * *dCnt);
return; // return dCnt
}
if (NULL == dCaps) return;
theErr = CGGetActiveDisplayList(maxDspys, dspys, dCnt);
if (theErr) return; // theErr getting list
if (0 == *dCnt) return; // no displays
memset (dCaps, 0, size * *dCnt); // zero memory
for (i = 0; i < *dCnt; i++) {
// get device ids
dCaps[i].cgDisplayID = dspys[i];
dCaps[i].cglDisplayMask = CGDisplayIDToOpenGLDisplayMask(dspys[i]);
{ // get current geometry
CGRect displayRect = CGDisplayBounds (dspys[i]);
// get mode dictionary
CFDictionaryRef dispMode = CGDisplayCurrentMode (dspys[i]);
dCaps[i].deviceWidth = (long) displayRect.size.width;
dCaps[i].deviceHeight = (long) displayRect.size.height;
dCaps[i].deviceOriginX = (long) displayRect.origin.x;
dCaps[i].deviceOriginY = (long) displayRect.origin.y;
dCaps[i].deviceDepth = (short) _getDictLong (dispMode,
kCGDisplayBitsPerPixel);
dCaps[i].deviceRefresh = (short) (_getDictDouble (dispMode,
kCGDisplayRefreshRate) + 0.5);
}
{ // get renderer info based on gDevice
CGLRendererInfoObj info;
long j;
GLint numRenderers = 0;
GLint rv = 0;
CGLError theErr2 = 0;
theErr2 = CGLQueryRendererInfo (dCaps[i].cglDisplayMask,
&info,
&numRenderers);
if(0 == theErr2) {
CGLDescribeRenderer (info, 0, kCGLRPRendererCount, &numRenderers);
for (j = 0; j < numRenderers; j++) {
// find accelerated renderer (assume only one)
CGLDescribeRenderer (info, j, kCGLRPAccelerated, &rv);
if (true == rv) { // if accelerated
// what is the renderer ID
CGLDescribeRenderer (info, j, kCGLRPRendererID,
&dCaps[i].rendererID);
// can we do full screen?
CGLDescribeRenderer (info, j, kCGLRPFullScreen, &rv);
dCaps[i].fullScreenCapable = (bool) rv;
// what is the VRAM?
CGLDescribeRenderer (info, j, kCGLRPVideoMemory,
&dCaps[i].deviceVRAM);
// what is the current texture memory?
CGLDescribeRenderer (info, j, kCGLRPTextureMemory,
&dCaps[i].deviceTextureRAM);
break; // done
}
}
}
CGLDestroyRendererInfo (info);
}
{ // build context and context specific info
CGLPixelFormatAttribute attribs[] = { kCGLPFADisplayMask,
dCaps[i].cglDisplayMask,
(CGLPixelFormatAttribute)0 };
CGLPixelFormatObj pixelFormat = NULL;
GLint numPixelFormats = 0;
CGLContextObj cglContext;
curr_ctx = CGLGetCurrentContext (); // get current CGL context
CGLChoosePixelFormat (attribs, &pixelFormat, &numPixelFormats);
if (pixelFormat) {
CGLCreateContext(pixelFormat, NULL, &cglContext);
CGLDestroyPixelFormat (pixelFormat);
CGLSetCurrentContext (cglContext);
if (cglContext) {
const GLubyte * strExt;
const GLubyte * strRend;
const GLubyte * strVers;
const GLubyte * strVend;
// get renderer strings
strRend = glGetString (GL_RENDERER);
strncpy (dCaps[i].strRendererName, (char *) strRend, 255);
strVend = glGetString (GL_VENDOR);
strncpy (dCaps[i].strRendererVendor, (char *) strVend, 255);
strVers = glGetString (GL_VERSION);
strncpy (dCaps[i].strRendererVersion, (char *) strVers, 255);
{ // get BCD version
short j = 0;
short shiftVal = 8;
while (((strVers[j] <= '9') && (strVers[j] >= '0')) ||
(strVers[j] == '.')) {
// get only basic version info (until first non-digit or non-.)
if ((strVers[j] <= '9') && (strVers[j] >= '0')) {
dCaps[i].glVersion += (strVers[j] - '0') << shiftVal;
shiftVal -= 4;
}
j++;
}
}
strExt = glGetString (GL_EXTENSIONS);
// get caps
glGetIntegerv (GL_MAX_TEXTURE_UNITS,
&dCaps[i].textureUnits);
glGetIntegerv (GL_MAX_TEXTURE_SIZE,
&dCaps[i].maxTextureSize);
glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE,
&dCaps[i].max3DTextureSize);
glGetIntegerv (GL_MAX_CUBE_MAP_TEXTURE_SIZE,
&dCaps[i].maxCubeMapTextureSize);
// get functionality info
dCaps[i].fSpecularVector =
gluCheckExtension ((const GLubyte *) "GL_APPLE_specular_vector", strExt);
dCaps[i].fTransformHint =
gluCheckExtension ((const GLubyte *) "GL_APPLE_transform_hint", strExt);
dCaps[i].fPackedPixels =
gluCheckExtension ((const GLubyte *) "GL_APPLE_packed_pixels", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_APPLE_packed_pixel", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fClientStorage =
gluCheckExtension ((const GLubyte *) "GL_APPLE_client_storage", strExt);
dCaps[i].fYCbCr =
gluCheckExtension ((const GLubyte *) "GL_APPLE_ycbcr_422", strExt);
dCaps[i].fTextureRange =
gluCheckExtension ((const GLubyte *) "GL_APPLE_texture_range", strExt);
dCaps[i].fFence =
gluCheckExtension ((const GLubyte *) "GL_APPLE_fence", strExt);
dCaps[i].fVAR =
gluCheckExtension ((const GLubyte *) "GL_APPLE_vertex_array_range", strExt);
dCaps[i].fVAO =
gluCheckExtension ((const GLubyte *) "GL_APPLE_vertex_array_object", strExt);
dCaps[i].fElementArray =
gluCheckExtension ((const GLubyte *) "GL_APPLE_element_array", strExt);
dCaps[i].fVPEvals =
gluCheckExtension ((const GLubyte *) "GL_APPLE_vertex_program_evaluators",strExt);
dCaps[i].fFloatPixels =
gluCheckExtension ((const GLubyte *) "GL_APPLE_float_pixels", strExt);
dCaps[i].fFlushRenderer =
gluCheckExtension ((const GLubyte *) "GL_APPLE_flush_render", strExt);
dCaps[i].fPixelBuffer =
gluCheckExtension ((const GLubyte *) "GL_APPLE_pixel_buffer", strExt);
dCaps[i].fImaging =
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fTransposeMatrix =
gluCheckExtension ((const GLubyte *) "GL_ARB_transpose_matrix", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fMultitexture =
gluCheckExtension ((const GLubyte *) "GL_ARB_multitexture", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvAdd =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_add", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_env_add", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvCombine =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_combine", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvDot3 =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_dot3", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexEnvCrossbar =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_env_crossbar", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fTexCubeMap =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_cube_map", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexCompress =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_compression", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fMultisample =
gluCheckExtension ((const GLubyte *) "GL_ARB_multisample", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fTexBorderClamp =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_border_clamp", strExt) ||
(dCaps[i].glVersion >= 0x0130);
dCaps[i].fPointParam =
gluCheckExtension ((const GLubyte *) "GL_ARB_point_parameters", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fVertexProg =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_program", strExt);
dCaps[i].fFragmentProg =
gluCheckExtension ((const GLubyte *) "GL_ARB_fragment_program", strExt);
dCaps[i].fTexMirrorRepeat =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_mirrored_repeat", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fDepthTex =
gluCheckExtension ((const GLubyte *) "GL_ARB_depth_texture", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fShadow =
gluCheckExtension ((const GLubyte *) "GL_ARB_shadow", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fShadowAmbient =
gluCheckExtension ((const GLubyte *) "GL_ARB_shadow_ambient", strExt);
dCaps[i].fVertexBlend =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_blend", strExt);
dCaps[i].fWindowPos =
gluCheckExtension ((const GLubyte *) "GL_ARB_window_pos", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fTex3D =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture3D", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fClipVolHint =
gluCheckExtension ((const GLubyte *) "GL_EXT_clip_volume_hint", strExt);
dCaps[i].fRescaleNorm =
gluCheckExtension ((const GLubyte *) "GL_EXT_rescale_normal", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fBlendColor =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_color", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fBlendMinMax =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_minmax", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fBlendSub =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_subtract", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fCVA =
gluCheckExtension ((const GLubyte *) "GL_EXT_compiled_vertex_array", strExt);
dCaps[i].fTexLODBias =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_lod_bias", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fABGR =
gluCheckExtension ((const GLubyte *) "GL_EXT_abgr", strExt);
dCaps[i].fBGRA =
gluCheckExtension ((const GLubyte *) "GL_EXT_bgra", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fTexFilterAniso =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_filter_anisotropic",strExt);
dCaps[i].fPaletteTex =
gluCheckExtension ((const GLubyte *) "GL_EXT_paletted_texture", strExt);
dCaps[i].fShareTexPalette =
gluCheckExtension ((const GLubyte *) "GL_EXT_shared_texture_palette", strExt);
dCaps[i].fSecColor =
gluCheckExtension ((const GLubyte *) "GL_EXT_secondary_color", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fTexCompressS3TC =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_compression_s3tc", strExt);
dCaps[i].fTexRect =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_rectangle", strExt);
dCaps[i].fFogCoord =
gluCheckExtension ((const GLubyte *) "GL_EXT_fog_coord", strExt);
dCaps[i].fDrawRangeElements =
gluCheckExtension ((const GLubyte *) "GL_EXT_draw_range_elements", strExt);
dCaps[i].fStencilWrap =
gluCheckExtension ((const GLubyte *) "GL_EXT_stencil_wrap", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fBlendFuncSep =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_func_separate", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fMultiDrawArrays =
gluCheckExtension ((const GLubyte *) "GL_EXT_multi_draw_arrays", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fShadowFunc =
gluCheckExtension ((const GLubyte *) "GL_EXT_shadow_funcs", strExt);
dCaps[i].fStencil2Side =
gluCheckExtension ((const GLubyte *) "GL_EXT_stencil_two_side", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fColorSubtable =
gluCheckExtension ((const GLubyte *) "GL_EXT_color_subtable", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fConvolution =
gluCheckExtension ((const GLubyte *) "GL_EXT_convolution", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fHistogram =
gluCheckExtension ((const GLubyte *) "GL_EXT_histogram", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fColorTable =
gluCheckExtension ((const GLubyte *) "GL_SGI_color_table", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fColorMatrix =
gluCheckExtension ((const GLubyte *) "GL_SGI_color_matrix", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fTexEdgeClamp =
gluCheckExtension ((const GLubyte *) "GL_SGIS_texture_edge_clamp", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fGenMipmap =
gluCheckExtension ((const GLubyte *) "GL_SGIS_generate_mipmap", strExt);
dCaps[i].fTexLOD =
gluCheckExtension ((const GLubyte *) "GL_SGIS_texture_lod", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fPointCull =
gluCheckExtension ((const GLubyte *) "GL_ATI_point_cull_mode", strExt);
dCaps[i].fTexMirrorOnce =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_mirror_once", strExt);
dCaps[i].fPNtriangles =
gluCheckExtension ((const GLubyte *) "GL_ATI_pn_triangles", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ATIX_pn_triangles", strExt);
dCaps[i].fTextFragShader =
gluCheckExtension ((const GLubyte *) "GL_ATI_text_fragment_shader", strExt);
dCaps[i].fATIBlendEqSep =
gluCheckExtension ((const GLubyte *) "GL_ATI_blend_equation_separate", strExt);
dCaps[i].fBlendWeightMinMax =
gluCheckExtension ((const GLubyte *) "GL_ATI_blend_weighted_minmax", strExt);
dCaps[i].fCombine3 =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_env_combine3", strExt);
dCaps[i].fSepStencil =
gluCheckExtension ((const GLubyte *) "GL_ATI_separate_stencil", strExt);
dCaps[i].fArrayRevComps4Byte =
gluCheckExtension ((const GLubyte *) "GL_ATI_array_rev_comps_in_4_bytes",strExt);
dCaps[i].fNVPointSprite =
gluCheckExtension ((const GLubyte *) "GL_NV_point_sprite", strExt);
dCaps[i].fRegCombiners =
gluCheckExtension ((const GLubyte *) "GL_NV_register_combiners", strExt);
dCaps[i].fRegCombiners2 =
gluCheckExtension ((const GLubyte *) "GL_NV_register_combiners2", strExt);
dCaps[i].fTexEnvCombine4 =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_env_combine4", strExt);
dCaps[i].fBlendSquare =
gluCheckExtension ((const GLubyte *) "GL_NV_blend_square", strExt) ||
(dCaps[i].glVersion >= 0x0140);
dCaps[i].fFogDist =
gluCheckExtension ((const GLubyte *) "GL_NV_fog_distance", strExt);
dCaps[i].fMultisampleFilterHint =
gluCheckExtension ((const GLubyte *) "GL_NV_multisample_filter_hint", strExt);
dCaps[i].fTexGenReflect =
gluCheckExtension ((const GLubyte *) "GL_NV_texgen_reflection", strExt);
dCaps[i].fTexShader =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_shader", strExt);
dCaps[i].fTexShader2 =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_shader2", strExt);
dCaps[i].fTexShader3 =
gluCheckExtension ((const GLubyte *) "GL_NV_texture_shader3", strExt);
dCaps[i].fDepthClamp =
gluCheckExtension ((const GLubyte *) "GL_NV_depth_clamp", strExt);
dCaps[i].fLightMaxExp =
gluCheckExtension ((const GLubyte *) "GL_NV_light_max_exponent", strExt);
dCaps[i].fRasterPosClip =
gluCheckExtension ((const GLubyte *) "GL_IBM_rasterpos_clip", strExt);
dCaps[i].fConvBorderModes =
gluCheckExtension ((const GLubyte *) "GL_HP_convolution_border_modes", strExt) ||
gluCheckExtension ((const GLubyte *) "GL_ARB_imaging", strExt);
dCaps[i].fAuxDeptStencil =
gluCheckExtension ((const GLubyte *) "GL_APPLE_aux_depth_stencil", strExt);
dCaps[i].fFlushBufferRange =
gluCheckExtension ((const GLubyte *) "GL_APPLE_flush_buffer_range", strExt);
dCaps[i].fObjectPurgeable =
gluCheckExtension ((const GLubyte *) "GL_APPLE_object_purgeable", strExt);
dCaps[i].fDrawBuffers =
gluCheckExtension ((const GLubyte *) "GL_ARB_draw_buffers", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fFragmentProgShadow =
gluCheckExtension ((const GLubyte *) "GL_ARB_fragment_program_shadow", strExt);
dCaps[i].fFragmentShader =
gluCheckExtension ((const GLubyte *) "GL_ARB_fragment_shader", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fHalfFloatPixel =
gluCheckExtension ((const GLubyte *) "GL_ARB_half_float_pixel", strExt);
dCaps[i].fOcclusionQuery =
gluCheckExtension ((const GLubyte *) "GL_ARB_occlusion_query", strExt) ||
(dCaps[i].glVersion >= 0x0150);
dCaps[i].fPBO =
gluCheckExtension ((const GLubyte *) "GL_ARB_pixel_buffer_object", strExt) ||
(dCaps[i].glVersion >= 0x0210);
dCaps[i].fPointSprite =
gluCheckExtension ((const GLubyte *) "GL_ARB_point_sprite", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fShaderObjects =
gluCheckExtension ((const GLubyte *) "GL_ARB_shader_objects", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fShaderTextureLOD =
gluCheckExtension ((const GLubyte *) "GL_ARB_shader_texture_lod", strExt);
dCaps[i].fShadingLanguage100 =
gluCheckExtension ((const GLubyte *) "GL_ARB_shading_language_100", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fTexFloat =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_float", strExt);
dCaps[i].fTexNPOT =
gluCheckExtension ((const GLubyte *) "GL_ARB_texture_non_power_of_two", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fVBO =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_buffer_object", strExt) ||
(dCaps[i].glVersion >= 0x0150);
dCaps[i].fVertexShader =
gluCheckExtension ((const GLubyte *) "GL_ARB_vertex_shader", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fTexComp3dc =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_compression_3dc", strExt);
dCaps[i].fTexATIfloat =
gluCheckExtension ((const GLubyte *) "GL_ATI_texture_float", strExt);
dCaps[i].fBlendEqSep =
gluCheckExtension ((const GLubyte *) "GL_EXT_blend_equation_separate", strExt) ||
(dCaps[i].glVersion >= 0x0200);
dCaps[i].fDepthBounds =
gluCheckExtension ((const GLubyte *) "GL_EXT_depth_bounds_test", strExt);
dCaps[i].fFBOblit =
gluCheckExtension ((const GLubyte *) "GL_EXT_framebuffer_blit", strExt);
dCaps[i].fFBO =
gluCheckExtension ((const GLubyte *) "GL_EXT_framebuffer_object", strExt);
dCaps[i].fGeometryShader4 =
gluCheckExtension ((const GLubyte *) "GL_EXT_geometry_shader4", strExt);
dCaps[i].fGPUProgParams =
gluCheckExtension ((const GLubyte *) "GL_EXT_gpu_program_parameters", strExt);
dCaps[i].fGPUShader4 =
gluCheckExtension ((const GLubyte *) "GL_EXT_gpu_shader4", strExt);
dCaps[i].fDepthStencil =
gluCheckExtension ((const GLubyte *) "GL_EXT_packed_depth_stencil", strExt);
dCaps[i].fSepSpecColor =
gluCheckExtension ((const GLubyte *) "GL_EXT_separate_specular_color", strExt) ||
(dCaps[i].glVersion >= 0x0120);
dCaps[i].fTexCompDXT1 =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_compression_dxt1", strExt);
dCaps[i].fTexMirrorClamp =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_mirror_clamp", strExt);
dCaps[i].fTexSRGB =
gluCheckExtension ((const GLubyte *) "GL_EXT_texture_sRGB", strExt) ||
(dCaps[i].glVersion >= 0x0210);
if (dCaps[i].fTexRect) // only check if extension supported
glGetIntegerv (GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT,
&dCaps[i].maxRectTextureSize);
else
dCaps[i].maxRectTextureSize = 0;
CGLDestroyContext (cglContext);
}
}
CGLSetCurrentContext (curr_ctx); // reset current CGL context
}
}
}
//-------------------------------------------------------------------------------------------------//
void OSXWindow::createCGLFullscreen(unsigned int width, unsigned int height, unsigned int depth, unsigned int fsaa, CGLContextObj sharedContext)
{
// Find the best match to what was requested
boolean_t exactMatch = 0;
int reqWidth, reqHeight, reqDepth;
#if defined(MAC_OS_X_VERSION_10_6) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
// Get a copy of the current display mode
CGDisplayModeRef displayMode = CGDisplayCopyDisplayMode(kCGDirectMainDisplay);
// Loop through all display modes to determine the closest match.
// CGDisplayBestModeForParameters is deprecated on 10.6 so we will emulate it's behavior
// Try to find a mode with the requested depth and equal or greater dimensions first.
// If no match is found, try to find a mode with greater depth and same or greater dimensions.
// If still no match is found, just use the current mode.
CFArrayRef allModes = CGDisplayCopyAllDisplayModes(kCGDirectMainDisplay, NULL);
for(int i = 0; i < CFArrayGetCount(allModes); i++)
{
CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(allModes, i);
String modeString = StringConverter::toString(CGDisplayModeGetWidth(mode)) + String(" x ") +
StringConverter::toString(CGDisplayModeGetHeight(mode)) + String(" @ ") +
StringConverter::toString(bitDepthFromDisplayMode(mode)) + "bpp.";
LogManager::getSingleton().logMessage(modeString);
if(bitDepthFromDisplayMode(mode) != depth)
continue;
if((CGDisplayModeGetWidth(mode) >= width) && (CGDisplayModeGetHeight(mode) >= height))
{
displayMode = mode;
exactMatch = 1;
break;
}
}
// No depth match was found
if(!exactMatch)
{
for(int i = 0; i < CFArrayGetCount(allModes); i++)
{
CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(allModes, i);
if(bitDepthFromDisplayMode(mode) >= depth)
continue;
if((CGDisplayModeGetWidth(mode) >= width) && (CGDisplayModeGetHeight(mode) >= height))
{
displayMode = mode;
exactMatch = 1;
break;
}
}
}
reqWidth = CGDisplayModeGetWidth(displayMode);
reqHeight = CGDisplayModeGetHeight(displayMode);
reqDepth = bitDepthFromDisplayMode(displayMode);
#else
CFDictionaryRef displayMode = CGDisplayBestModeForParameters(kCGDirectMainDisplay, depth, width, height, &exactMatch);
const void *value = NULL;
value = CFDictionaryGetValue(displayMode, kCGDisplayWidth);
CFNumberGetValue((CFNumberRef)value, kCFNumberSInt32Type, &reqWidth);
value = CFDictionaryGetValue(displayMode, kCGDisplayHeight);
CFNumberGetValue((CFNumberRef)value, kCFNumberSInt32Type, &reqHeight);
value = CFDictionaryGetValue(displayMode, kCGDisplayBitsPerPixel);
CFNumberGetValue((CFNumberRef)value, kCFNumberSInt32Type, &reqDepth);
#endif
if(!exactMatch)
{
// TODO: Report the size difference
// That mode is not available, using the closest match
String request = StringConverter::toString(width) + String(" x ") + StringConverter::toString(height) + String(" @ ") +
StringConverter::toString(depth) + "bpp. ";
String received = StringConverter::toString(reqWidth) + String(" x ") +
StringConverter::toString(reqHeight) + String(" @ ") +
StringConverter::toString(reqDepth) + "bpp. ";
LogManager::getSingleton().logMessage(String("RenderSystem Warning: You requested a fullscreen mode of ") + request +
String(" This mode is not available and you will receive the closest match. The best display mode for the parameters requested is: ")
+ received);
}
// Do the fancy display fading
CGDisplayFadeReservationToken reservationToken;
CGAcquireDisplayFadeReservation(kCGMaxDisplayReservationInterval,
&reservationToken);
CGDisplayFade(reservationToken,
0.5,
kCGDisplayBlendNormal,
kCGDisplayBlendSolidColor,
0.0, 0.0, 0.0,
true);
// Grab the main display and save it for later.
// You could render to any display, but picking what display
// to render to could be interesting.
CGDisplayCapture(kCGDirectMainDisplay);
// Switch to the correct resolution
#if defined(MAC_OS_X_VERSION_10_6) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
CGDisplaySetDisplayMode(kCGDirectMainDisplay, displayMode, NULL);
#else
CGDisplaySwitchToMode(kCGDirectMainDisplay, displayMode);
#endif
// Get a pixel format that best matches what we are looking for
CGLPixelFormatAttribute attribs[] = {
kCGLPFADoubleBuffer,
kCGLPFAAlphaSize, (CGLPixelFormatAttribute)8,
kCGLPFADepthSize, (CGLPixelFormatAttribute)reqDepth,
kCGLPFAStencilSize, (CGLPixelFormatAttribute)8,
kCGLPFASampleBuffers, (CGLPixelFormatAttribute)0,
kCGLPFASamples, (CGLPixelFormatAttribute)0,
kCGLPFAFullScreen,
kCGLPFASingleRenderer,
kCGLPFAAccelerated,
kCGLPFADisplayMask, (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay),
(CGLPixelFormatAttribute)0
};
// Set up FSAA if it was requested
if(fsaa > 1)
{
// turn on kCGLPFASampleBuffers
attribs[8] = (CGLPixelFormatAttribute)1;
// set the samples for kCGLPFASamples
attribs[10] = (CGLPixelFormatAttribute)fsaa;
}
CGLError err;
CGLPixelFormatObj pixelFormatObj;
#if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
GLint numPixelFormats = 0;
err = CGLChoosePixelFormat(attribs, &pixelFormatObj, &numPixelFormats);
#else
long numPixelFormats = 0;
err = CGLChoosePixelFormat(attribs, &pixelFormatObj, &numPixelFormats);
#endif
if(err != 0)
{
CGReleaseAllDisplays();
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, String("CGL Error: " + String(CGLErrorString(err))), "OSXWindow::createCGLFullscreen");
}
// Create the CGLcontext from our pixel format, share it with the sharedContext passed in
err = CGLCreateContext(pixelFormatObj, sharedContext, &mCGLContext);
if(err != 0)
{
CGReleaseAllDisplays();
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, String("CGL Error: " + String(CGLErrorString(err))), "OSXWindow::createCGLFullscreen");
}
// Once we have the context we can destroy the pixel format
// In order to share contexts you must keep a pointer to the context object around
// Our context class will now manage the life of the pixelFormatObj
//CGLDestroyPixelFormat(pixelFormatObj);
// Set the context to full screen
#if defined(MAC_OS_X_VERSION_10_6) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
CGLSetFullScreenOnDisplay(mCGLContext, CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay));
#else
CGLSetFullScreen(mCGLContext);
#endif
// Set the context as current
CGLSetCurrentContext(mCGLContext);
// This synchronizes CGL with the vertical retrace
// Apple docs suggest that OpenGL blocks rendering calls when waiting for
// a vertical retrace anyhow.
#if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
GLint swapInterval = 1;
CGLSetParameter(mCGLContext, kCGLCPSwapInterval, &swapInterval);
#else
long swapInterval = 1;
CGLSetParameter(mCGLContext, kCGLCPSwapInterval, &swapInterval);
#endif
// Give a copy of our context to the rendersystem
mContext = new OSXCGLContext(mCGLContext, pixelFormatObj);
// Let everyone know we are fullscreen now
mIsFullScreen = true;
// Set some other variables. Just in case we got a different value from CGDisplayBestModeForParameters than we requested
mWidth = reqWidth;
mHeight = reqHeight;
mColourDepth = reqDepth;
CGDisplayFade(reservationToken,
2.0,
kCGDisplayBlendSolidColor,
kCGDisplayBlendNormal,
0.0, 0.0, 0.0,
false);
CGReleaseDisplayFadeReservation(reservationToken);
}