void OSXCarbonWindow::createWindowFromExternal(HIViewRef viewRef)
{
// TODO: The Control is going to report the incorrect location with a
// Metallic / Textured window. The default windows work just fine.
// First get the HIViewRef / ControlRef
mView = viewRef;
mWindow = GetControlOwner(mView);
// Lets try hiding the HIView
//HIViewSetVisible(mView, false);
// Get the rect bounds
::Rect ctrlBounds;
GetControlBounds(mView, &ctrlBounds);
GLint bufferRect[4];
bufferRect[0] = ctrlBounds.left; // left edge
bufferRect[1] = ctrlBounds.bottom; // bottom edge
bufferRect[2] = ctrlBounds.right - ctrlBounds.left; // width of buffer rect
bufferRect[3] = ctrlBounds.bottom - ctrlBounds.top; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(mAGLContext, AGL_BUFFER_RECT);
mIsExternal = true;
}
void wxGLCanvas::SetViewport()
{
// viewport is initially set to entire port
// adjust glViewport to just this window
int x = 0 ;
int y = 0 ;
wxWindow* iter = this ;
while( iter->GetParent() )
{
iter = iter->GetParent() ;
}
if ( iter && iter->IsTopLevel() )
{
MacClientToRootWindow( &x , &y ) ;
int width, height;
GetClientSize(& width, & height);
Rect bounds ;
GetWindowPortBounds( MAC_WXHWND(MacGetRootWindow()) , &bounds ) ;
GLint parms[4] ;
parms[0] = x ;
parms[1] = bounds.bottom - bounds.top - ( y + height ) ;
parms[2] = width ;
parms[3] = height ;
if ( !m_macCanvasIsShown )
parms[0] += 20000 ;
aglSetInteger( m_glContext->m_glContext , AGL_BUFFER_RECT , parms ) ;
}
}
/////////////////////////////////////////////////////////
// windowInit
//
/////////////////////////////////////////////////////////
void GemMan :: windowInit()
{
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearDepth(1.0);
glClearColor(m_clear_color[0], m_clear_color[1], m_clear_color[2], m_clear_color[3]);
#ifdef __APPLE__
GLint swapInt = 1;
aglSetInteger ( gfxInfo.context, AGL_SWAP_INTERVAL, &swapInt);
#endif
/* i am not really sure whether it is a good idea to enable FSAA by default
* this might slow down everything a lot;
* JMZ: additionally, we should not enable it, without checking first,
* whether GL_NV_multisample_filter_hint is supported by the backend
*/
if(GLEW_ARB_multisample)
glEnable (GL_MULTISAMPLE_ARB);
if(GLEW_NV_multisample_filter_hint)
glHint (GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
resetValues();
}
bool wxGLContext::SetCurrent(const wxGLCanvas& win) const
{
if ( !m_glContext )
return false;
GLint bufnummer = win.GetAglBufferName();
aglSetInteger(m_glContext, AGL_BUFFER_NAME, &bufnummer);
//win.SetLastContext(m_glContext);
const_cast<wxGLCanvas&>(win).SetViewport();
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
if ( UMAGetSystemVersion() >= 0x1050 )
{
aglSetWindowRef(m_glContext, win.MacGetTopLevelWindowRef());
}
else
#endif
{
AGLDrawable drawable = (AGLDrawable)GetWindowPort(
MAC_WXHWND(win.MacGetTopLevelWindowRef()));
if ( !aglSetDrawable(m_glContext, drawable) )
{
wxLogAGLError("aglSetDrawable");
return false;
}
}
return WXGLSetCurrentContext(m_glContext);
}
bool wxGLContext::SetCurrent(const wxGLCanvas& win) const
{
if ( !m_glContext )
return false;
AGLDrawable drawable = (AGLDrawable)GetWindowPort(
MAC_WXHWND(win.MacGetTopLevelWindowRef()));
GLint bufnummer = win.GetAglBufferName();
aglSetInteger(m_glContext, AGL_BUFFER_NAME, &bufnummer);
//win.SetLastContext(m_glContext);
const_cast<wxGLCanvas&>(win).SetViewport();
if ( !aglSetDrawable(m_glContext, drawable) )
{
wxLogAGLError("aglSetDrawable");
return false;
}
if ( !aglSetCurrentContext(m_glContext) )
{
wxLogAGLError("aglSetCurrentContext");
return false;
}
return true;
}
uint QGLContext::colorIndex(const QColor&c) const
{
int ret = -1;
if(!cmap_init) {
cmap_init = true;
for(int i = 0; i < 256; i++)
cmap[i] = QColor();
} else {
for(int i = 0; i < 256; i++) {
if(cmap[i].isValid() && cmap[i] == c) {
ret = i;
break;
}
}
}
if(ret == -1) {
for(ret = 0; ret < 256; ret++)
if(!cmap[ret].isValid())
break;
if(ret == 256) {
ret = -1;
qWarning("QGLContext::colorIndex(): Internal error!");
} else {
cmap[ret] = c;
GLint vals[4];
vals[0] = ret;
vals[1] = c.red();
vals[2] = c.green();
vals[3] = c.blue();
aglSetInteger((AGLContext)d_func()->cx, AGL_COLORMAP_ENTRY, vals);
}
}
return (uint)(ret == -1 ? 0 : ret);
}
bool wxGLCanvas::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name,
const int *attribList,
const wxPalette& WXUNUSED(palette))
{
m_needsUpdate = false;
m_macCanvasIsShown = false;
m_glFormat = WXGLChoosePixelFormat(attribList);
if ( !m_glFormat )
return false;
if ( !wxWindow::Create(parent, id, pos, size, style, name) )
return false;
m_dummyContext = WXGLCreateContext(m_glFormat, NULL);
static GLint gCurrentBufferName = 1;
m_bufferName = gCurrentBufferName++;
aglSetInteger (m_dummyContext, AGL_BUFFER_NAME, &m_bufferName);
AGLDrawable drawable = (AGLDrawable)GetWindowPort(MAC_WXHWND(MacGetTopLevelWindowRef()));
aglSetDrawable(m_dummyContext, drawable);
m_macCanvasIsShown = true;
return true;
}
Error ContextGL_OSX::initialize() {
if ((Ptr)kUnresolvedCFragSymbolAddress == (Ptr)aglChoosePixelFormat)
return FAILED;
GLint attributes[] = { AGL_RGBA,
AGL_DOUBLEBUFFER,
AGL_DEPTH_SIZE, 32,
AGL_NO_RECOVERY,
AGL_NONE,
AGL_NONE };
AGLPixelFormat format = NULL;
format = aglChoosePixelFormat(NULL, 0, attributes);
if (!format)
return FAILED;
context = aglCreateContext(format, 0);
if (!context)
return FAILED;
aglDestroyPixelFormat(format);
aglSetWindowRef(context, window);
GLint swapInterval = 1;
aglSetInteger(context, AGL_SWAP_INTERVAL, &swapInterval);
aglSetCurrentContext(context);
return OK;
}
AGLContext create_gl(WindowRef wref)
{
GLint major, minor;
AGLContext ctx;
aglGetVersion(&major, &minor);
SkDebugf("---- agl version %d %d\n", major, minor);
const GLint pixelAttrs[] = {
AGL_RGBA,
AGL_STENCIL_SIZE, 8,
#if USE_MSAA
AGL_SAMPLE_BUFFERS_ARB, 1,
AGL_MULTISAMPLE,
AGL_SAMPLES_ARB, 8,
#endif
AGL_ACCELERATED,
AGL_DOUBLEBUFFER,
AGL_NONE
};
AGLPixelFormat format = aglChoosePixelFormat(NULL, 0, pixelAttrs);
//AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs);
SkDebugf("----- agl format %p\n", format);
ctx = aglCreateContext(format, NULL);
SkDebugf("----- agl context %p\n", ctx);
aglDestroyPixelFormat(format);
static const GLint interval = 1;
aglSetInteger(ctx, AGL_SWAP_INTERVAL, &interval);
aglSetCurrentContext(ctx);
return ctx;
}
void OSXCarbonWindow::setVisible( bool visible )
{
mVisible = visible;
if(mIsExternal && !visible) {
GLint bufferRect[4] = {0, 0, 0, 0};
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
}
}
void _glfwPlatformSwapInterval( int interval )
{
GLint parameter = interval;
// Don't care if we fail here
(void)aglSetInteger( _glfwWin.AGLContext,
AGL_SWAP_INTERVAL,
¶meter );
}
static void HIOpenGLViewSetContextWindowAndBounds (HIOpenGLViewData* inData)
{
if (inData == nil) return;
if (inData->mControl == nil) return;
if (inData->mContext == nil) return;
// Determine the AGL_BUFFER_RECT for the control. The coordinate
// system for this rectangle is relative to the owning window, with
// the origin at the bottom left corner and the y-axis inverted.
HIRect ctrlBounds, winBounds;
HIViewGetBounds(inData->mControl, &ctrlBounds);
WindowRef window = GetControlOwner(inData->mControl);
ControlRef root = nil;
GetRootControl(window, &root);
HIViewGetBounds(root, &winBounds);
HIViewConvertRect(&ctrlBounds, inData->mControl, root);
GLint bufferRect[4] = { (int)ctrlBounds.origin.x, (int)((winBounds.size.height) - (ctrlBounds.origin.y + ctrlBounds.size.height)),
(int)ctrlBounds.size.width, (int)ctrlBounds.size.height };
// Associate the OpenGL context with the control's window, and establish the buffer rect.
aglSetDrawable(inData->mContext, GetWindowPort(window));
aglSetInteger(inData->mContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(inData->mContext, AGL_BUFFER_RECT);
// Establish the clipping region for the OpenGL context. To properly handle clipping
// within the view hierarchy, I'm walking the hierarchy to determine the intersection
// of this view's bounds with its parents. Is there an easier way to do this?
CGRect clipBounds = ctrlBounds;
HIViewRef parent = HIViewGetSuperview(inData->mControl);
while (parent != root)
{
CGRect parentBounds;
HIViewGetBounds(parent, &parentBounds);
HIViewConvertRect(&parentBounds, parent, root);
clipBounds = CGRectIntersection(clipBounds, parentBounds);
parent = HIViewGetSuperview(parent);
}
Rect rgnBounds = { (int)clipBounds.origin.y, (int)clipBounds.origin.x, (int)(clipBounds.origin.y + clipBounds.size.height), (int)(clipBounds.origin.x + clipBounds.size.width) };
RgnHandle rgn = NewRgn();
RectRgn(rgn, &rgnBounds);
aglSetInteger(inData->mContext, AGL_CLIP_REGION, (const GLint*)rgn);
aglEnable(inData->mContext, AGL_CLIP_REGION);
}
void CL_DisplayWindow_OpenGL::flip(int interval)
{
CL_GLStateChecker::from_gc(get_gc())->flush();
if (interval != -1)
{
GLint param = interval;
aglSetInteger(context, AGL_SWAP_INTERVAL, ¶m);
}
aglSwapBuffers(context);
}
void Window::_initSwapSync( AGLContext context )
{
if( getIAttribute( WindowSettings::IATTR_HINT_DRAWABLE ) == OFF )
return;
int32_t swapSync = getIAttribute( WindowSettings::IATTR_HINT_SWAPSYNC );
if( swapSync == AUTO )
return;
if( swapSync < 0 )
swapSync = 1;
aglSetInteger( context, AGL_SWAP_INTERVAL, &swapSync );
}
void wxGLCanvas::SetViewport()
{
#ifndef __LP64__
// viewport is initially set to entire port
// adjust glViewport to just this window
int x = 0 ;
int y = 0 ;
wxWindow* iter = this ;
while( iter->GetParent() )
{
iter = iter->GetParent() ;
}
if ( iter && iter->IsTopLevel() )
{
MacClientToRootWindow( &x , &y ) ;
int width, height;
GetClientSize(& width, & height);
Rect bounds ;
#if 0
// TODO in case we adopt point vs pixel coordinates, this will make the conversion
GetWindowPortBounds( MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds ) ;
HIRect hiRect = CGRectMake( x, y, width, height ) ;
HIRectConvert( &hiRect, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceScreenPixel, NULL) ;
HIRect hiBounds = CGRectMake( 0, 0, bounds.right - bounds.left , bounds.bottom - bounds.top ) ;
HIRectConvert( &hiBounds, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceScreenPixel, NULL) ;
GLint parms[4] ;
parms[0] = hiRect.origin.x ;
parms[1] = hiBounds.size.height - (hiRect.origin.y + hiRect.size.height) ;
parms[2] = hiRect.size.width ;
parms[3] = hiRect.size.height ;
#else
GetWindowPortBounds( MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds ) ;
GLint parms[4] ;
parms[0] = x ;
parms[1] = bounds.bottom - bounds.top - ( y + height ) ;
parms[2] = width ;
parms[3] = height ;
#endif
if ( !m_macCanvasIsShown )
parms[0] += 20000 ;
aglSetInteger( m_glContext->m_glContext , AGL_BUFFER_RECT , parms ) ;
aglUpdateContext(m_glContext->m_glContext);
}
#endif
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::windowMovedOrResized()
{
// External windows will call this method.
if(mView != NULL)
{
// Determine the AGL_BUFFER_RECT for the view. The coordinate
// system for this rectangle is relative to the owning window, with
// the origin at the bottom left corner and the y-axis inverted.
// Also, when leaving fullscreen, the display properties are not guaranteed to be
// the same as when we were windowed previously. So resize the window and views back
// to their original dimensions.
HIRect newFrame = CGRectMake(mLeft, mTop+22, mWidth, mHeight);
HIRect viewBounds = CGRectZero, winBounds = CGRectZero;
SizeWindow(mWindow, mWidth, mHeight, true);
HIViewSetFrame(mView, &newFrame);
HIViewGetBounds(mView, &viewBounds);
HIViewRef root = HIViewGetRoot(HIViewGetWindow(mView));
HIViewGetBounds(root, &winBounds);
HIViewConvertRect(&viewBounds, mView, root);
// Set the AGL buffer rectangle (i.e. the bounds that we will use)
GLint bufferRect[4];
bufferRect[0] = viewBounds.origin.x; // 0 = left edge
bufferRect[1] = winBounds.size.height - (viewBounds.origin.y + viewBounds.size.height); // 0 = bottom edge
bufferRect[2] = viewBounds.size.width; // width of buffer rect
bufferRect[3] = viewBounds.size.height; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(mAGLContext, AGL_BUFFER_RECT);
aglUpdateContext(mAGLContext);
mLeft = viewBounds.origin.x;
mTop = bufferRect[1];
}
for (ViewportList::iterator it = mViewportList.begin(); it != mViewportList.end(); ++it)
{
(*it).second->_updateDimensions();
}
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::windowResized()
{
// Ensure the context is current
if(!mIsFullScreen)
{
// Determine the AGL_BUFFER_RECT for the view. The coordinate
// system for this rectangle is relative to the owning window, with
// the origin at the bottom left corner and the y-axis inverted.
HIRect newFrame = CGRectMake(mLeft, mTop+22, mWidth, mHeight);
HIRect viewBounds = CGRectZero, winBounds = CGRectZero;
SizeWindow(mWindow, mWidth, mHeight, true);
HIViewSetFrame(mView, &newFrame);
HIViewGetBounds(mView, &viewBounds);
HIViewRef root = HIViewGetRoot(HIViewGetWindow(mView));
HIViewGetBounds(root, &winBounds);
HIViewConvertRect(&viewBounds, mView, root);
// Set the AGL buffer rectangle (i.e. the bounds that we will use)
GLint bufferRect[4];
bufferRect[0] = viewBounds.origin.x; // 0 = left edge
bufferRect[1] = winBounds.size.height - (viewBounds.origin.y + viewBounds.size.height); // 0 = bottom edge
bufferRect[2] = viewBounds.size.width; // width of buffer rect
bufferRect[3] = viewBounds.size.height; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(mAGLContext, AGL_BUFFER_RECT);
aglUpdateContext(mAGLContext);
mLeft = viewBounds.origin.x;
mTop = bufferRect[1];
}
else
{
swapCGLBuffers();
}
for (ViewportList::iterator it = mViewportList.begin(); it != mViewportList.end(); ++it)
{
(*it).second->_updateDimensions();
}
}
void wxGLCanvas::SetViewport()
{
if ( !m_needsUpdate )
return;
m_needsUpdate = false;
// AGLContext context = aglGetCurrentContext();
// if ( !context )
// return;
// viewport is initially set to entire port, adjust it to just this window
int x = 0,
y = 0;
MacClientToRootWindow(&x , &y);
int width, height;
GetClientSize(&width, &height);
Rect bounds;
GetWindowPortBounds(MAC_WXHWND(MacGetTopLevelWindowRef()) , &bounds);
GLint parms[4];
parms[0] = x;
parms[1] = bounds.bottom - bounds.top - ( y + height );
parms[2] = width;
parms[3] = height;
// move the buffer rect out of sight if we're hidden
if ( !m_macCanvasIsShown )
parms[0] += 20000;
if ( !aglSetInteger(m_dummyContext, AGL_BUFFER_RECT, parms) )
wxLogAGLError("aglSetInteger(AGL_BUFFER_RECT)");
if ( !aglEnable(m_dummyContext, AGL_BUFFER_RECT) )
wxLogAGLError("aglEnable(AGL_BUFFER_RECT)");
if ( !aglUpdateContext(m_dummyContext) )
wxLogAGLError("aglUpdateContext");
}
void _glfwPlatformSwapInterval( int interval )
{
GLint AGLparameter = interval;
// CGL doesn't seem to like intervals other than 0 (vsync off) or 1 (vsync on)
long CGLparameter = ( interval == 0 ? 0 : 1 );
if( !_glfwWin.Fullscreen )
{
// Don't care if we fail here..
(void)aglSetInteger( _glfwWin.AGLContext,
AGL_SWAP_INTERVAL,
&AGLparameter );
}
else
{
// ..or here
(void)CGLSetParameter( _glfwWin.CGLContext,
kCGLCPSwapInterval,
&CGLparameter );
}
}
void
PaneView::resize(short left, short top, short right, short bottom)
{
aglSetCurrentContext(_model._aglContext);
aglUpdateContext(_model._aglContext);
short width = right - left;
short height = bottom - top;
float aspectRatio = (float) width / (float) height;
// float fieldOfViewY = 45.0f * _model.getSpace().getCurrentShot().getCamera().getZoom();
float fieldOfViewY = 45.0f * _model.getSpace().getShots().next().getCamera().getZoom();
Rect portRect;
GetWindowPortBounds(_model._windowRef, &portRect);
short portHeight = portRect.bottom - portRect.top;
GLint bufferRect[4];
bufferRect[0] = _model._bounds->left; // x
bufferRect[1] = portHeight - _model._bounds->bottom; // y
bufferRect[2] = _model._bounds->right - _model._bounds->left; // width
bufferRect[3] = _model._bounds->bottom - _model._bounds->top; // height
aglSetInteger(_model._aglContext, AGL_BUFFER_RECT, bufferRect);
aglEnable(_model._aglContext, AGL_BUFFER_RECT);
// aglSetInteger(inData->mContext, AGL_CLIP_REGION, (const GLint*)rgn);
// aglEnable(inData->mContext, AGL_CLIP_REGION);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fieldOfViewY, aspectRatio, 1.0f, 1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
InvalWindowRect(_model._windowRef, &portRect);
_model.getSpace().resize(width, height);
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::resize(unsigned int width, unsigned int height)
{
if(!mWindow)
return;
// Check if the window size really changed
if(mWidth == width && mHeight == height)
return;
mWidth = width;
mHeight = height;
if (mIsExternal)
{
HIRect viewBounds = CGRectZero, winBounds = CGRectZero;
HIViewGetBounds(mView, &viewBounds);
HIViewRef root = HIViewGetRoot(HIViewGetWindow(mView));
HIViewGetBounds(root, &winBounds);
HIViewConvertRect(&viewBounds, mView, root);
mLeft = viewBounds.origin.x;
mTop = winBounds.size.height - (viewBounds.origin.y + viewBounds.size.height);
// Set the AGL buffer rectangle (i.e. the bounds that we will use)
GLint bufferRect[4];
bufferRect[0] = mLeft; // 0 = left edge
bufferRect[1] = mTop; // 0 = bottom edge
bufferRect[2] = mWidth; // width of buffer rect
bufferRect[3] = mHeight; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
for (ViewportList::iterator it = mViewportList.begin(); it != mViewportList.end(); ++it)
{
(*it).second->_updateDimensions();
}
}
else
{
SizeWindow(mWindow, width, height, true);
}
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::windowMovedOrResized()
{
// External windows will call this method.
if(mView != NULL)
{
// Determine the AGL_BUFFER_RECT for the view. The coordinate
// system for this rectangle is relative to the owning window, with
// the origin at the bottom left corner and the y-axis inverted.
HIRect viewBounds, winBounds;
HIViewGetBounds(mView, &viewBounds);
HIViewRef root = HIViewGetRoot(HIViewGetWindow(mView));
HIViewGetBounds(root, &winBounds);
HIViewConvertRect(&viewBounds, mView, root);
// Set the AGL buffer rectangle (i.e. the bounds that we will use)
GLint bufferRect[4];
bufferRect[0] = viewBounds.origin.x; // 0 = left edge
bufferRect[1] = winBounds.size.height - (viewBounds.origin.y + viewBounds.size.height); // 0 = bottom edge
bufferRect[2] = viewBounds.size.width; // width of buffer rect
bufferRect[3] = viewBounds.size.height; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable (mAGLContext, AGL_BUFFER_RECT);
mWidth = viewBounds.size.width;
mHeight = viewBounds.size.height;
mLeft = viewBounds.origin.x;
mTop = bufferRect[1];
}
for (ViewportList::iterator it = mViewportList.begin(); it != mViewportList.end(); ++it)
{
(*it).second->_updateDimensions();
}
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::setVSyncEnabled(bool vsync)
{
mVSync = vsync;
mContext->setCurrent();
CGLContextObj share = NULL;
aglGetCGLContext(mAGLContext, (void**)&share);
GLint vsyncInterval = mVSync ? 1 : 0;
aglSetInteger(mAGLContext, AGL_SWAP_INTERVAL, &vsyncInterval);
mContext->endCurrent();
if(!mIsFullScreen)
{
if(mAGLContext != aglGetCurrentContext())
aglSetCurrentContext(mAGLContext);
}
else
{
if(share != CGLGetCurrentContext())
CGLSetCurrentContext(share);
}
}
bool nglContext::Build(WindowRef Win, const nglContextInfo& rInfo, const nglContext* pShared, bool Fullscreen)
{
mTargetAPI = rInfo.TargetAPI;
#ifndef __NOGLCONTEXT__
mFullscreen = Fullscreen;
std::vector<GLint> attribs;
attribs.push_back(AGL_RGBA);
if (rInfo.FrameCnt != 1)
attribs.push_back(AGL_DOUBLEBUFFER);
attribs.push_back(AGL_DEPTH_SIZE);
attribs.push_back(rInfo.DepthBits);
attribs.push_back(AGL_STENCIL_SIZE);
attribs.push_back(rInfo.StencilBits);
if (rInfo.AuxCnt)
{
attribs.push_back(AGL_AUX_BUFFERS);
attribs.push_back(rInfo.AuxCnt);
}
if (rInfo.AABufferCnt)
{
attribs.push_back(AGL_SAMPLE_BUFFERS_ARB);
attribs.push_back(rInfo.AABufferCnt);
attribs.push_back(AGL_SAMPLES_ARB);
attribs.push_back(rInfo.AASampleCnt);
}
attribs.push_back(AGL_RED_SIZE);
attribs.push_back(rInfo.FrameBitsR);
attribs.push_back(AGL_GREEN_SIZE);
attribs.push_back(rInfo.FrameBitsG);
attribs.push_back(AGL_BLUE_SIZE);
attribs.push_back(rInfo.FrameBitsB);
attribs.push_back(AGL_ALPHA_SIZE);
attribs.push_back(rInfo.FrameBitsA);
attribs.push_back(AGL_PIXEL_SIZE);
attribs.push_back(rInfo.FrameBitsR + rInfo.FrameBitsG + rInfo.FrameBitsB + rInfo.FrameBitsA);
if (rInfo.AccumBitsR || rInfo.AccumBitsG || rInfo.AccumBitsB || rInfo.AccumBitsA)
{
attribs.push_back(AGL_ACCUM_RED_SIZE);
attribs.push_back(rInfo.AccumBitsR);
attribs.push_back(AGL_ACCUM_GREEN_SIZE);
attribs.push_back(rInfo.AccumBitsG);
attribs.push_back(AGL_ACCUM_BLUE_SIZE);
attribs.push_back(rInfo.AccumBitsB);
attribs.push_back(AGL_ACCUM_ALPHA_SIZE);
attribs.push_back(rInfo.AccumBitsA);
}
if (rInfo.Stereo)
attribs.push_back(AGL_STEREO);
attribs.push_back(AGL_MINIMUM_POLICY);
attribs.push_back(AGL_NO_RECOVERY);
if (rInfo.CopyOnSwap)
attribs.push_back(AGL_BACKING_STORE);
attribs.push_back(AGL_NONE);
/* Choose pixel format */
AGLPixelFormat Format = aglChoosePixelFormat(NULL, 0, &attribs[0]);
//NGL_OUT("Pixel Format: 0x%x\n", Format);
if (!Format)
{
if (rInfo.CopyOnSwap)
{
attribs[attribs.size() - 2] = AGL_NONE;
Format = aglChoosePixelFormat(NULL, 0, &attribs[0]);
}
if (!Format)
{
SetError(_T("context"), NGL_CONTEXT_ENOMATCH);
return false;
}
}
//DumpFormat(Format);
/* Create an AGL context */
mCtx = aglCreateContext(Format, pShared?pShared->mCtx:NULL);
long err = aglGetError();
GLint value;
aglDescribePixelFormat(Format, AGL_DOUBLEBUFFER, &value);
mContextInfo.FrameCnt = value ? 2 : 1; ///< Number of frame buffers (two means double-buffering)
aglDescribePixelFormat(Format, AGL_RED_SIZE, (GLint*)&mContextInfo.FrameBitsR); ///< Bits per red component (frame buffer)
aglDescribePixelFormat(Format, AGL_GREEN_SIZE, (GLint*)&mContextInfo.FrameBitsG); ///< Bits per green component (frame buffer)
aglDescribePixelFormat(Format, AGL_BLUE_SIZE, (GLint*)&mContextInfo.FrameBitsB); ///< Bits per blue component (frame buffer)
aglDescribePixelFormat(Format, AGL_ALPHA_SIZE, (GLint*)&mContextInfo.FrameBitsA); ///< Bits per alpha component (frame buffer)
aglDescribePixelFormat(Format, AGL_DEPTH_SIZE, (GLint*)&mContextInfo.DepthBits); ///< Depth buffer resolution (ie. Z buffer, 0 means no Z buffer)
aglDescribePixelFormat(Format, AGL_STENCIL_SIZE, (GLint*)&mContextInfo.StencilBits); ///< Stencil buffer resolution (0 means no stencil)
aglDescribePixelFormat(Format, AGL_ACCUM_RED_SIZE, (GLint*)&mContextInfo.AccumBitsR); ///< Bits per red component (accumulator buffer)
aglDescribePixelFormat(Format, AGL_ACCUM_GREEN_SIZE, (GLint*)&mContextInfo.AccumBitsG); ///< Bits per green component (accumulator buffer)
aglDescribePixelFormat(Format, AGL_ACCUM_BLUE_SIZE, (GLint*)&mContextInfo.AccumBitsB); ///< Bits per blue component (accumulator buffer)
aglDescribePixelFormat(Format, AGL_ACCUM_ALPHA_SIZE, (GLint*)&mContextInfo.AccumBitsA); ///< Bits per alpha component (accumulator buffer)
aglDescribePixelFormat(Format, AGL_AUX_BUFFERS, (GLint*)&mContextInfo.AuxCnt); ///< Number of auxiliary buffers
aglDescribePixelFormat(Format, AGL_SAMPLE_BUFFERS_ARB, (GLint*)&mContextInfo.AABufferCnt); ///< Number of anti-aliasing buffers
aglDescribePixelFormat(Format, AGL_SAMPLES_ARB, (GLint*)&mContextInfo.AASampleCnt); ///< Anti-alisaing oversampling count
aglDescribePixelFormat(Format, AGL_STEREO, &value); ///< Stereoscopic display
mContextInfo.Stereo = value != 0;
mContextInfo.Offscreen = false; ///< This context can render in memory instead of to a window. (false by default).
mContextInfo.RenderToTexture = false; ///< This context must be able to be bound as a texture. (false by default)
aglDescribePixelFormat(Format, AGL_BACKING_STORE, &value); ///< This context must be able to use copy the back buffer to the front buffer instead of swaping them. (false by default)
mContextInfo.CopyOnSwap = value != 0;
if (rInfo.CopyOnSwap && !mContextInfo.CopyOnSwap)
mValidBackBufferRequestedNotGranted = true;
aglDestroyPixelFormat(Format);
if (!mCtx)
{
SetError(_T("context"), NGL_CONTEXT_EGLCTX);
/*
switch (err)
{
case AGL_BAD_MATCH:
NGL_OUT("AGL Error: Bad Context Match (shared context incompatible with requested pixel format).\n");
break;
case AGL_BAD_CONTEXT:
NGL_OUT("AGL Error: Bad Shared Context.\n");
break;
case AGL_BAD_PIXELFMT:
NGL_OUT("AGL Error: Bad Pixel Format.\n");
break;
default:
NGL_OUT("AGL Error: Unknown error\n");
break;
}
*/
return false;
}
/* Attach the context to the window */
if (!aglSetDrawable(mCtx, GetWindowPort (Win)))
{
SetError(_T("context"), NGL_CONTEXT_EBIND);
return false;
}
{
CGLError err = kCGLNoError;
CGLContextObj ctx = CGLGetCurrentContext();
// Enable the multi-threading
//err = CGLEnable( ctx, kCGLCEMPEngine);
if (err != kCGLNoError )
{
// Multi-threaded execution is possibly not available
// Insert your code to take appropriate action
}
}
GLint vsync = rInfo.VerticalSync ? 1 : 0;
aglSetInteger(mCtx, AGL_SWAP_INTERVAL, &vsync);
InitPainter();
MakeCurrent(Win);
#endif
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
return true;
}
/*****************************************************************************
QGLContext AGL-specific code
*****************************************************************************/
bool QGLContext::chooseContext(const QGLContext* shareContext)
{
Q_D(QGLContext);
d->cx = 0;
d->vi = chooseMacVisual(0);
if(!d->vi)
return false;
AGLPixelFormat fmt = (AGLPixelFormat)d->vi;
GLint res;
aglDescribePixelFormat(fmt, AGL_LEVEL, &res);
d->glFormat.setPlane(res);
if(deviceIsPixmap())
res = 0;
else
aglDescribePixelFormat(fmt, AGL_DOUBLEBUFFER, &res);
d->glFormat.setDoubleBuffer(res);
aglDescribePixelFormat(fmt, AGL_DEPTH_SIZE, &res);
d->glFormat.setDepth(res);
if (d->glFormat.depth())
d->glFormat.setDepthBufferSize(res);
aglDescribePixelFormat(fmt, AGL_RGBA, &res);
d->glFormat.setRgba(res);
aglDescribePixelFormat(fmt, AGL_RED_SIZE, &res);
d->glFormat.setRedBufferSize(res);
aglDescribePixelFormat(fmt, AGL_GREEN_SIZE, &res);
d->glFormat.setGreenBufferSize(res);
aglDescribePixelFormat(fmt, AGL_BLUE_SIZE, &res);
d->glFormat.setBlueBufferSize(res);
aglDescribePixelFormat(fmt, AGL_ALPHA_SIZE, &res);
d->glFormat.setAlpha(res);
if (d->glFormat.alpha())
d->glFormat.setAlphaBufferSize(res);
aglDescribePixelFormat(fmt, AGL_ACCUM_RED_SIZE, &res);
// Bug in Apple OpenGL (rdr://5015603), when we don't have an accumulation
// buffer, it still claims that we have a 16-bit one (which is pretty rare).
// So, we just assume we can never have a buffer that small.
d->glFormat.setAccum(res > 5);
if (d->glFormat.accum())
d->glFormat.setAccumBufferSize(res);
aglDescribePixelFormat(fmt, AGL_STENCIL_SIZE, &res);
d->glFormat.setStencil(res);
if (d->glFormat.stencil())
d->glFormat.setStencilBufferSize(res);
aglDescribePixelFormat(fmt, AGL_STEREO, &res);
d->glFormat.setStereo(res);
aglDescribePixelFormat(fmt, AGL_SAMPLE_BUFFERS_ARB, &res);
d->glFormat.setSampleBuffers(res);
if (d->glFormat.sampleBuffers()) {
aglDescribePixelFormat(fmt, AGL_SAMPLES_ARB, &res);
d->glFormat.setSamples(res);
}
if(shareContext && (!shareContext->isValid() || !shareContext->d_func()->cx)) {
qWarning("QGLContext::chooseContext(): Cannot share with invalid context");
shareContext = 0;
}
// sharing between rgba and color-index will give wrong colors
if(shareContext && (format().rgba() != shareContext->format().rgba()))
shareContext = 0;
AGLContext ctx = aglCreateContext(fmt, (AGLContext) (shareContext ? shareContext->d_func()->cx : 0));
if(!ctx) {
GLenum err = aglGetError();
if(err == AGL_BAD_MATCH || err == AGL_BAD_CONTEXT) {
if(shareContext && shareContext->d_func()->cx) {
qWarning("QGLContext::chooseContext(): Context sharing mismatch!");
if(!(ctx = aglCreateContext(fmt, 0)))
return false;
shareContext = 0;
}
}
if(!ctx) {
qWarning("QGLContext::chooseContext(): Unable to create QGLContext");
return false;
}
}
d->cx = ctx;
if (shareContext && shareContext->d_func()->cx) {
QGLContext *share = const_cast<QGLContext *>(shareContext);
d->sharing = true;
share->d_func()->sharing = true;
}
if(deviceIsPixmap())
updatePaintDevice();
// vblank syncing
GLint interval = d->reqFormat.swapInterval();
if (interval != -1) {
aglSetInteger((AGLContext)d->cx, AGL_SWAP_INTERVAL, &interval);
if (interval != 0)
aglEnable((AGLContext)d->cx, AGL_SWAP_INTERVAL);
else
aglDisable((AGLContext)d->cx, AGL_SWAP_INTERVAL);
}
aglGetInteger((AGLContext)d->cx, AGL_SWAP_INTERVAL, &interval);
d->glFormat.setSwapInterval(interval);
return true;
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::create( const String& name, unsigned int width, unsigned int height,
bool fullScreen, const NameValuePairList *miscParams )
{
bool hasDepthBuffer;
String title = name;
size_t fsaa_samples = 0;
int left = 0;
int top = 0;
int depth = 32;
if( miscParams )
{
NameValuePairList::const_iterator opt = NULL;
// Full screen anti aliasing
opt = miscParams->find( "FSAA" );
if( opt != miscParams->end() )
fsaa_samples = StringConverter::parseUnsignedInt( opt->second );
opt = miscParams->find( "left" );
if( opt != miscParams->end() )
left = StringConverter::parseUnsignedInt( opt->second );
opt = miscParams->find( "top" );
if( opt != miscParams->end() )
top = StringConverter::parseUnsignedInt( opt->second );
opt = miscParams->find( "title" );
if( opt != miscParams->end() )
title = opt->second;
opt = miscParams->find( "depthBuffer" );
if( opt != miscParams->end() )
hasDepthBuffer = StringConverter::parseBool( opt->second );
opt = miscParams->find( "colourDepth" );
if( opt != miscParams->end() )
depth = StringConverter::parseUnsignedInt( opt->second );
}
if(fullScreen)
{
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
OSXContext *mainContext = (OSXContext*)rs->_getMainContext();
CGLContextObj share = NULL;
if(mainContext == 0)
{
share = NULL;
}
else if(mainContext->getContextType() == "AGL")
{
OSXCarbonContext* aglShare = static_cast<OSXCarbonContext*>(mainContext);
aglGetCGLContext(aglShare->getContext(), &((void*)share));
}
else if(mainContext->getContextType() == "CGL")
{
OSXCGLContext* cglShare = static_cast<OSXCGLContext*>(mainContext);
share = cglShare->getContext();
}
// create the context
createCGLFullscreen(width, height, depth, fsaa_samples, share);
}
else
{
int i = 0;
AGLPixelFormat pixelFormat;
GLint attribs[ 20 ];
attribs[ i++ ] = AGL_NO_RECOVERY;
attribs[ i++ ] = GL_TRUE;
attribs[ i++ ] = AGL_ACCELERATED;
attribs[ i++ ] = GL_TRUE;
attribs[ i++ ] = AGL_RGBA;
attribs[ i++ ] = AGL_DOUBLEBUFFER;
attribs[ i++ ] = AGL_ALPHA_SIZE;
attribs[ i++ ] = 8;
attribs[ i++ ] = AGL_STENCIL_SIZE;
attribs[ i++ ] = 8;
attribs[ i++ ] = AGL_DEPTH_SIZE;
attribs[ i++ ] = depth;
if(fsaa_samples > 1)
{
attribs[ i++ ] = AGL_MULTISAMPLE;
attribs[ i++ ] = 1;
attribs[ i++ ] = AGL_SAMPLE_BUFFERS_ARB;
attribs[ i++ ] = fsaa_samples;
}
attribs[ i++ ] = AGL_NONE;
pixelFormat = aglChoosePixelFormat( NULL, 0, attribs );
// Create the AGLContext from our pixel format
// Share it with main
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
OSXContext* mainContext = static_cast<OSXContext*>( rs->_getMainContext() );
if(mainContext == 0)
{
mAGLContext = aglCreateContext(pixelFormat, NULL);
}
else if(mainContext->getContextType() == "AGL")
{
OSXCarbonContext* context = static_cast<OSXCarbonContext*>( rs->_getMainContext() );
AGLContext shared = context->getContext();
mAGLContext = aglCreateContext(pixelFormat, context->getContext());
}
else
{
// If we do not have an AGL, we can not clone it using this window
LogManager::getSingleton().logMessage( "Warning: You asked to create a second window, "
"when the previous window was not of this type. OgreOSXCarbonWindow can only share "
"with an AGL context.");
}
NameValuePairList::const_iterator opt = 0;
if(miscParams)
opt = miscParams->find("externalWindowHandle");
if(!miscParams || opt == miscParams->end())
{
// create the window rect in global coords
::Rect windowRect;
windowRect.left = 0;
windowRect.top = 0;
windowRect.right = width;
windowRect.bottom = height;
// set the default attributes for the window
WindowAttributes windowAttrs = kWindowStandardDocumentAttributes; // default: "resize"
if (miscParams)
{
opt = miscParams->find("border");
if( opt != miscParams->end() )
{
String borderType = opt->second;
if( borderType == "none" )
windowAttrs = kWindowNoTitleBarAttribute;
else if( borderType == "fixed" )
windowAttrs = kWindowStandardFloatingAttributes;
}
}
windowAttrs |= kWindowStandardHandlerAttribute | kWindowInWindowMenuAttribute | kWindowHideOnFullScreenAttribute;
// Create the window
CreateNewWindow(kDocumentWindowClass, windowAttrs, &windowRect, &mWindow);
// Color the window background black
SetThemeWindowBackground (mWindow, kThemeBrushBlack, true);
// Set the title of our window
CFStringRef titleRef = CFStringCreateWithCString( kCFAllocatorDefault, title.c_str(), kCFStringEncodingASCII );
SetWindowTitleWithCFString( mWindow, titleRef );
// Center our window on the screen
RepositionWindow( mWindow, NULL, kWindowCenterOnMainScreen );
// Get our view
HIViewFindByID( HIViewGetRoot( mWindow ), kHIViewWindowContentID, &mView );
// Set up our UPP for Window Events
EventTypeSpec eventSpecs[] = {
{kEventClassWindow, kEventWindowActivated},
{kEventClassWindow, kEventWindowDeactivated},
{kEventClassWindow, kEventWindowShown},
{kEventClassWindow, kEventWindowHidden},
{kEventClassWindow, kEventWindowDragCompleted},
{kEventClassWindow, kEventWindowBoundsChanged},
{kEventClassWindow, kEventWindowExpanded},
{kEventClassWindow, kEventWindowCollapsed},
{kEventClassWindow, kEventWindowClosed},
{kEventClassWindow, kEventWindowClose}
};
EventHandlerUPP handlerUPP = NewEventHandlerUPP(WindowEventUtilities::_CarbonWindowHandler);
// Install the standard event handler for the window
EventTargetRef target = GetWindowEventTarget(mWindow);
InstallStandardEventHandler(target);
// We also need to install the WindowEvent Handler, we pass along the window with our requests
InstallEventHandler(target, handlerUPP, 10, eventSpecs, (void*)this, &mEventHandlerRef);
// Display and select our window
ShowWindow(mWindow);
SelectWindow(mWindow);
// Add our window to the window event listener class
WindowEventUtilities::_addRenderWindow(this);
}
else
{
// TODO: The Contol is going to report the incorrect location with a
// Metalic / Textured window. The default windows work just fine.
// First get the HIViewRef / ControlRef
mView = (HIViewRef)StringConverter::parseUnsignedLong(opt->second);
mWindow = GetControlOwner(mView);
// Lets try hiding the HIView
//HIViewSetVisible(mView, false);
// Get the rect bounds
::Rect ctrlBounds;
GetControlBounds(mView, &ctrlBounds);
GLint bufferRect[4];
bufferRect[0] = ctrlBounds.left; // left edge
bufferRect[1] = ctrlBounds.bottom; // bottom edge
bufferRect[2] = ctrlBounds.right - ctrlBounds.left; // width of buffer rect
bufferRect[3] = ctrlBounds.bottom - ctrlBounds.top; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable (mAGLContext, AGL_BUFFER_RECT);
mIsExternal = true;
}
// Set the drawable, and current context
// If you do this last, there is a moment before the rendering window pops-up
// This could go once inside each case above, before the window is displayed,
// if desired.
aglSetDrawable(mAGLContext, GetWindowPort(mWindow));
aglSetCurrentContext(mAGLContext);
// Give a copy of our context to the render system
mContext = new OSXCarbonContext(mAGLContext, pixelFormat);
}
mName = name;
mWidth = width;
mHeight = height;
mActive = true;
mClosed = false;
mCreated = true;
mIsFullScreen = fullScreen;
}
void QGLContext::updatePaintDevice()
{
Q_D(QGLContext);
d->update = false;
#if 0 //(MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
if(d->paintDevice->devType() == QInternal::Widget) {
QWidget *w = (QWidget *)d->paintDevice;
aglSetHIViewRef((AGLContext)d->cx, (HIViewRef)w->winId());
} else if(d->paintDevice->devType() == QInternal::Pixmap) {
QPixmap *pm = (QPixmap *)d->paintDevice;
aglSetOffScreen((AGLContext)d->cx, pm->width(), pm->height(),
qt_mac_pixmap_get_bytes_per_line(pm), qt_mac_pixmap_get_base(pm));
} else {
qWarning("QGLContext::updatePaintDevice(): Not sure how to render OpenGL on this device!");
}
} else
#endif
{
#ifndef Q_OS_MAC64
if(d->paintDevice->devType() == QInternal::Widget) {
//get control information
QWidget *w = (QWidget *)d->paintDevice;
HIViewRef hiview = (HIViewRef)w->winId();
WindowPtr window = qt_mac_window_for(hiview);
#ifdef DEBUG_OPENGL_REGION_UPDATE
static int serial_no_gl = 0;
qDebug("[%d] %p setting on %s::%s %p/%p [%s]", ++serial_no_gl, w,
w->metaObject()->className(), w->objectName().toLatin1().constData(),
hiview, window, w->handle() ? "Inside" : "Outside");
#endif
//update drawable
if(0 && w->isWindow() && w->isFullScreen()) {
aglSetDrawable((AGLContext)d->cx, 0);
aglSetFullScreen((AGLContext)d->cx, w->width(), w->height(), 0, QApplication::desktop()->screenNumber(w));
w->hide();
} else {
AGLDrawable old_draw = aglGetDrawable((AGLContext)d->cx), new_draw = GetWindowPort(window);
if(old_draw != new_draw)
aglSetDrawable((AGLContext)d->cx, new_draw);
}
if(!w->isWindow()) {
QRegion clp = qt_mac_get_widget_rgn(w); //get drawable area
#ifdef DEBUG_OPENGL_REGION_UPDATE
if(clp.isEmpty()) {
qDebug(" Empty area!");
} else {
QVector<QRect> rs = clp.rects();
for(int i = 0; i < rs.count(); i++)
qDebug(" %d %d %d %d", rs[i].x(), rs[i].y(), rs[i].width(), rs[i].height());
}
#endif
//update the clip
if(!aglIsEnabled((AGLContext)d->cx, AGL_BUFFER_RECT))
aglEnable((AGLContext)d->cx, AGL_BUFFER_RECT);
if(clp.isEmpty()) {
GLint offs[4] = { 0, 0, 0, 0 };
aglSetInteger((AGLContext)d->cx, AGL_BUFFER_RECT, offs);
if(aglIsEnabled((AGLContext)d->cx, AGL_CLIP_REGION))
aglDisable((AGLContext)d->cx, AGL_CLIP_REGION);
} else {
HIPoint origin = { 0., 0. };
HIViewConvertPoint(&origin, HIViewRef(w->winId()), 0);
const GLint offs[4] = { qRound(origin.x),
w->window()->frameGeometry().height()
- (qRound(origin.y) + w->height()),
w->width(), w->height() };
aglSetInteger((AGLContext)d->cx, AGL_BUFFER_RECT, offs);
aglSetInteger((AGLContext)d->cx, AGL_CLIP_REGION, (const GLint *)clp.handle(true));
if(!aglIsEnabled((AGLContext)d->cx, AGL_CLIP_REGION))
aglEnable((AGLContext)d->cx, AGL_CLIP_REGION);
}
}
} else if(d->paintDevice->devType() == QInternal::Pixmap) {
QPixmap *pm = (QPixmap *)d->paintDevice;
PixMapHandle mac_pm = GetGWorldPixMap((GWorldPtr)pm->macQDHandle());
aglSetOffScreen((AGLContext)d->cx, pm->width(), pm->height(),
GetPixRowBytes(mac_pm), GetPixBaseAddr(mac_pm));
} else {
qWarning("QGLContext::updatePaintDevice(): Not sure how to render OpenGL on this device!");
}
#endif // Q_OS_MAC64
}
aglUpdateContext((AGLContext)d->cx);
}
static int RLXAPI CreateSurface(int numberOfSparePages)
{
static GLint attrib[32];
GLint *pAttrib = attrib;
*pAttrib = AGL_RGBA; pAttrib++;
*pAttrib = AGL_DOUBLEBUFFER; pAttrib++;
*pAttrib = AGL_NONE; pAttrib++;
AGLPixelFormat fmt;
GLboolean ok;
g_pRLX->pGX->View.lpBackBuffer = NULL;
/* Choose an rgb pixel format */
GDHandle gdhDisplay;
ok = DMGetGDeviceByDisplayID((DisplayIDType)g_cgDisplayID, &gdhDisplay, false);
SYS_ASSERT(ok == noErr);
fmt = aglChoosePixelFormat(&gdhDisplay, 1, attrib);
SYS_AGLTRACE(0);
if(fmt == NULL)
{
ok = SYS_AGLTRACE(aglGetError());
return -1;
}
/* Create an AGL context */
g_pAGLC = aglCreateContext(fmt, NULL);
SYS_AGLTRACE(0);
if(g_pAGLC == NULL)
return -2;
/* Attach the window to the context */
ok = SYS_AGLTRACE(aglSetDrawable(g_pAGLC, GetWindowPort(g_hWnd)));
if(!ok)
return -3;
/* Make the context the current context */
ok = SYS_AGLTRACE(aglSetCurrentContext(g_pAGLC));
if(!ok)
return -4;
SizeWindow(g_hWnd, gl_lx, gl_ly, true);
if ((g_pRLX->Video.Config & RLXVIDEO_Windowed))
CenterWindow(g_hWnd);
ShowWindow(g_hWnd);
// copy portRect
GetPortBounds(GetWindowPort(g_hWnd), g_pRect);
/* Pixel format is no more needed */
aglDestroyPixelFormat(fmt);
if (!(g_pRLX->Video.Config & RLXVIDEO_Windowed))
{
HideMenuBar();
aglSetFullScreen(g_pAGLC, 0, 0, 0, 0);
GLint swap = !!(g_pRLX->pGX->View.Flags & GX_CAPS_VSYNC);
aglSetInteger(g_pAGLC, AGL_SWAP_INTERVAL, &swap);
SYS_AGLTRACE(0);
}
// Reset engine
GL_InstallExtensions();
GL_ResetViewport();
g_pRLX->pGX->Surfaces.maxSurface = numberOfSparePages;;
if (g_pRLX->pGX->View.Flags & GX_CAPS_MULTISAMPLING)
{
glEnable(GL_MULTISAMPLE_ARB);
}
return 0;
}
