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;
}
bool SkOSWindow::attachGL()
{
if (NULL == fAGLCtx) {
fAGLCtx = create_gl((WindowRef)fHWND);
if (NULL == fAGLCtx) {
return false;
}
}
GLboolean success = true;
int width, height;
success = aglSetWindowRef((AGLContext)fAGLCtx, (WindowRef)fHWND);
width = this->width();
height = this->height();
GLenum err = aglGetError();
if (err) {
SkDebugf("---- aglSetWindowRef %d %d %s [%d %d]\n", success, err,
aglErrorString(err), width, height);
}
if (success) {
glViewport(0, 0, width, height);
glClearColor(0, 0, 0, 0);
glClearStencil(0);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
return success;
}
void Window::configExit()
{
WindowRef window = getCarbonWindow();
setCarbonWindow( 0 );
AGLContext context = getAGLContext();
if( getIAttribute( WindowSettings::IATTR_HINT_FULLSCREEN ) == ON )
{
LBASSERT( !window );
exitEventHandler();
}
else if( window )
{
Global::enterCarbon();
aglSetWindowRef( context, 0 );
DisposeWindow( window );
Global::leaveCarbon();
}
configExitFBO();
exitGLEW();
if( context )
{
Global::enterCarbon();
aglSetCurrentContext( 0 );
aglDestroyContext( context );
Global::leaveCarbon();
setAGLContext( 0 );
}
LBVERB << "Destroyed AGL window and context" << std::endl;
}
static void setup_offscreen_gl(const SkBitmap& offscreen, WindowRef wref) {
GLboolean success = true;
#ifdef USE_OFFSCREEN
success = aglSetOffScreen(gAGLContext,
offscreen.width(),
offscreen.height(),
offscreen.rowBytes(),
offscreen.getPixels());
#else
success = aglSetWindowRef(gAGLContext, wref);
#endif
GLenum err = aglGetError();
if (err) {
SkDebugf("---- setoffscreen %d %d %s [%d %d]\n", success, err,
aglErrorString(err), offscreen.width(), offscreen.height());
}
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glEnable(GL_TEXTURE_2D);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
}
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);
}
static void deleteContext(AGLContext ctx) {
if (g_Window.fs) {
aglSetFullScreen(ctx, 0, 0, 0, 0);
} else {
aglSetWindowRef(ctx, 0);
}
aglSetCurrentContext(0);
aglDestroyContext(ctx);
}
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);
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
if ( UMAGetSystemVersion() >= 0x1050 )
{
aglSetWindowRef(m_dummyContext, MacGetTopLevelWindowRef());
}
else
#endif
{
AGLDrawable drawable = (AGLDrawable)GetWindowPort(MAC_WXHWND(MacGetTopLevelWindowRef()));
aglSetDrawable(m_dummyContext, drawable);
}
m_macCanvasIsShown = true;
return true;
}
SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) {
#ifdef SK_SUPPORT_GL
#ifndef USE_OFFSCREEN
aglSetWindowRef(gAGLContext, NULL);
#endif
#endif
switch (fCanvasType) {
case kRaster_CanvasType:
canvas = this->INHERITED::beforeChildren(canvas);
break;
case kPicture_CanvasType:
fPicture = new SkPicture;
canvas = fPicture->beginRecording(9999, 9999);
break;
#ifdef SK_SUPPORT_GL
case kOpenGL_CanvasType: {
//SkGLCanvas::DeleteAllTextures(); // just for testing
SkDevice* device = canvas->getDevice();
const SkBitmap& bitmap = device->accessBitmap(true);
// first clear the raster bitmap, so we don't see any leftover bits
bitmap.eraseColor(0);
// now setup our glcanvas
setup_offscreen_gl(bitmap, (WindowRef)this->getHWND());
fGLCanvas = new SkGLCanvas;
fGLCanvas->setViewport(bitmap.width(), bitmap.height());
canvas = fGLCanvas;
break;
}
#endif
}
if (fUseClip) {
canvas->drawColor(0xFFFF88FF);
canvas->clipPath(fClipPath);
}
return canvas;
}
bool Window::configInitAGLWindow()
{
AGLContext context = getAGLContext();
if( !context )
{
sendError( ERROR_AGLWINDOW_NO_CONTEXT );
return false;
}
// window
const bool decoration =
getIAttribute(WindowSettings::IATTR_HINT_DECORATION) != OFF;
WindowAttributes winAttributes = ( decoration ?
kWindowStandardDocumentAttributes :
kWindowNoTitleBarAttribute |
kWindowNoShadowAttribute |
kWindowResizableAttribute ) |
kWindowStandardHandlerAttribute | kWindowInWindowMenuAttribute;
// top, left, bottom, right
const PixelViewport& pvp = getPixelViewport();
const int32_t menuHeight = decoration ? EQ_AGL_MENUBARHEIGHT : 0 ;
Rect windowRect = { short( pvp.y + menuHeight ), short( pvp.x ),
short( pvp.getYEnd() + menuHeight ),
short( pvp.getXEnd( ))
};
WindowRef windowRef;
Global::enterCarbon();
const OSStatus status = CreateNewWindow( kDocumentWindowClass,
winAttributes,
&windowRect, &windowRef );
if( status != noErr )
{
sendError( ERROR_AGLWINDOW_CREATEWINDOW_FAILED )
<< lexical_cast< std::string >( status );
Global::leaveCarbon();
return false;
}
// window title
const std::string& name = getName();
std::stringstream windowTitle;
if( name.empty( ))
{
windowTitle << "Equalizer";
#ifndef NDEBUG
windowTitle << " (" << getpid() << ")";
#endif
}
else
windowTitle << name;
CFStringRef title = CFStringCreateWithCString( kCFAllocatorDefault,
windowTitle.str().c_str(),
kCFStringEncodingMacRoman );
SetWindowTitleWithCFString( windowRef, title );
CFRelease( title );
if( !aglSetWindowRef( context, windowRef ))
{
sendError( ERROR_AGLWINDOW_SETWINDOW_FAILED ) << aglError();
Global::leaveCarbon();
return false;
}
// show
ShowWindow( windowRef );
// Do focus hell
ProcessSerialNumber selfProcess = { 0, kCurrentProcess };
SetFrontProcess( &selfProcess );
Global::leaveCarbon();
setCarbonWindow( windowRef );
return true;
}
void OSXCarbonWindow::setFullscreen(bool fullScreen, unsigned int width, unsigned int height)
{
if (mIsFullScreen != fullScreen || width != mWidth || height != mHeight)
{
// Set the full screen flag
mIsFullScreen = fullScreen;
createAGLContext(mFSAA, mColourDepth);
if (mIsFullScreen)
{
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
CGLContextObj share = NULL;
aglGetCGLContext(mAGLContext, (void**)&share);
// Create the CGL context object if it doesn't already exist, sharing the AGL context.
if(!mCGLContext)
{
void *cglPixFormat;
aglGetCGLPixelFormat(mAGLPixelFormat, (void **)&cglPixFormat);
mCGLContext = OGRE_NEW OSXCGLContext(mCGLContextObj, (CGLPixelFormatObj) cglPixFormat);
}
// Create the context, keeping the current colour depth and FSAA settings
createCGLFullscreen(width, height, getColourDepth(), getFSAA(), share);
rs->_switchContext(mContext);
// Hide the Carbon window
HideWindow(mWindow);
// And tell the rendersystem to stop rendering to it too
WindowEventUtilities::_removeRenderWindow(this);
}
else
{
// Create a new AGL context and pixel format if necessary
createAGLContext(mFSAA, mColourDepth);
// Create a window if we haven't already, existence check is done within the functions
if(!mWindow)
{
if(mIsExternal)
createWindowFromExternal(mView);
else
createNewWindow(width, height, mWindowTitle);
}
// Destroy the current CGL context, we will create a new one when/if we go back to full screen
destroyCGLFullscreen();
// Set the drawable, and current context
// If you do this last, there is a moment before the rendering window pops-up
#if defined(MAC_OS_X_VERSION_10_4) && MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4
aglSetDrawable(mAGLContext, GetWindowPort(mWindow));
#else
aglSetWindowRef(mAGLContext, mWindow);
#endif
aglSetCurrentContext(mAGLContext);
if(!mCarbonContext)
{
mCarbonContext = OGRE_NEW OSXCarbonContext(mAGLContext, mAGLPixelFormat);
}
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
mContext = mCarbonContext;
rs->_switchContext(mContext);
WindowEventUtilities::_addRenderWindow(this);
ShowWindow(mWindow);
SelectWindow(mWindow);
RepositionWindow(mWindow, NULL, kWindowCenterOnMainScreen);
}
mWidth = width;
mHeight = height;
}
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::create( const String& name, unsigned int width, unsigned int height,
bool fullScreen, const NameValuePairList *miscParams )
{
bool hasDepthBuffer = false;
String title = name;
size_t fsaa_samples = 0;
int left = 0;
int top = 0;
bool vsync = false;
bool hidden = false;
int depth = 32;
if( miscParams )
{
NameValuePairList::const_iterator opt(NULL);
NameValuePairList::const_iterator end = miscParams->end();
// Full screen anti aliasing
if((opt = miscParams->find("FSAA")) != end)
fsaa_samples = StringConverter::parseUnsignedInt( opt->second );
if((opt = miscParams->find("left")) != end)
left = StringConverter::parseUnsignedInt( opt->second );
if((opt = miscParams->find("top")) != end)
top = StringConverter::parseUnsignedInt( opt->second );
if((opt = miscParams->find("title")) != end)
title = opt->second;
if((opt = miscParams->find("vsync")) != end)
vsync = StringConverter::parseBool(opt->second);
if((opt = miscParams->find("hidden")) != end)
hidden = StringConverter::parseBool(opt->second);
if((opt = miscParams->find("gamma")) != end)
mHwGamma = StringConverter::parseBool(opt->second);
if((opt = miscParams->find("depthBuffer")) != end)
hasDepthBuffer = StringConverter::parseBool( opt->second );
if((opt = miscParams->find("colourDepth")) != end)
depth = StringConverter::parseUnsignedInt( opt->second );
if((opt = miscParams->find("Full Screen")) != end)
fullScreen = StringConverter::parseBool( opt->second );
}
if(fullScreen)
{
setFullscreen(fullScreen, width, height);
}
else
{
createAGLContext(fsaa_samples, depth);
NameValuePairList::const_iterator opt(NULL);
if(miscParams)
opt = miscParams->find("externalWindowHandle");
if(!miscParams || opt == miscParams->end())
createNewWindow(width, height, title.c_str());
else
createWindowFromExternal((HIViewRef)StringConverter::parseUnsignedLong(opt->second));
// 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.
#if defined(MAC_OS_X_VERSION_10_4) && MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4
aglSetDrawable(mAGLContext, GetWindowPort(mWindow));
#else
aglSetWindowRef(mAGLContext, mWindow);
#endif
aglSetCurrentContext(mAGLContext);
// Give a copy of our context to the render system
if(!mCarbonContext)
{
mCarbonContext = OGRE_NEW OSXCarbonContext(mAGLContext, mAGLPixelFormat);
mContext = mCarbonContext;
}
}
// Apply vsync settings. call setVSyncInterval first to avoid
// setting vsync more than once.
setVSyncEnabled(vsync);
setHidden(hidden);
mName = name;
mWidth = width;
mHeight = height;
mColourDepth = depth;
mFSAA = fsaa_samples;
mIsFullScreen = fullScreen;
mActive = true;
mClosed = false;
mCreated = true;
}
void SkOSWindow::detachGL() {
aglSetWindowRef((AGLContext)fAGLCtx, NULL);
}
bool CSMNativeWindow::init(void)
{
osx_AllowForeground();
CSMDrawer *pDrawer = this->getParent();
CarbonWindowUnrecPtr pCarbonWindow = OSG::CarbonWindow::create();
AGLPixelFormat pixelFormat = NULL;
std::vector<int> pfForm;
pfForm.push_back(AGL_RGBA);
pfForm.push_back(AGL_DEPTH_SIZE);
pfForm.push_back(16);
pfForm.push_back(AGL_DOUBLEBUFFER);
if(_sfRequestSamples.getValue() > 0)
{
pfForm.push_back(AGL_SAMPLE_BUFFERS_ARB);
pfForm.push_back(1);
pfForm.push_back(AGL_SAMPLES_ARB);
pfForm.push_back(_sfRequestSamples.getValue());
}
if(this->requestStereoVisual() == true)
{
fprintf(stderr, "Choose stereo format\n");
pfForm.push_back(AGL_STEREO);
}
pfForm.push_back(AGL_NONE);
pixelFormat = aglChoosePixelFormat(NULL, 0, &(pfForm.front()));
fprintf(stderr, "Got pf : %p\n", pixelFormat);
if(pixelFormat == NULL)
{
fprintf(stderr, "no RGB visual with depth buffer : :0.0");
exit(0);
}
_pContext = aglCreateContext(pixelFormat, 0);
aglDestroyPixelFormat(pixelFormat);
UInt32 uiWidth;
UInt32 uiHeight;
Int32 iXPos = 0;
Int32 iYPos = 0;
if(this->getXPos() > 0.f && this->getYPos() > 0.f)
{
iXPos = Int32(this->getXPos());
iYPos = Int32(this->getYPos());
}
if(this->getXSize() >= 1.f)
{
uiWidth = UInt32(this->getXSize());
}
else if(this->getXSize() <= 0.f)
{
uiWidth = 300; //DisplayWidth(_pDisplay, vi->screen);
}
else
{
uiWidth = 300; //UInt32(Real32(DisplayWidth(_pDisplay, vi->screen)) *
// this->getXSize());
}
if(this->getYSize() >= 1.f)
{
uiHeight = UInt32(this->getYSize());
}
else if(this->getYSize() <= 0.f)
{
uiHeight = 300; //DisplayHeight(_pDisplay, vi->screen);
}
else
{
uiHeight = 300; //UInt32(Real32(DisplayHeight(_pDisplay, vi->screen)) *
// this->getYSize());
}
WindowAttributes windowAttrs = (kWindowStandardDocumentAttributes |
kWindowLiveResizeAttribute |
kWindowStandardHandlerAttribute );
Rect contentRect;
SetRect(&contentRect, iXPos, iYPos, iXPos + uiWidth, iYPos + uiHeight);
CreateNewWindow(kDocumentWindowClass, windowAttrs, &contentRect,
&_pLocalWindow);
SetWindowTitleWithCFString(_pLocalWindow, CFSTR("OpenSG - CSM"));
// Install event handler
_pEventHandler = NewEventHandlerUPP(eventHandler);
EventTypeSpec eventList[] =
{
{ kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
{ kEventClassMouse, kEventMouseDown },
{ kEventClassMouse, kEventMouseUp },
{ kEventClassMouse, kEventMouseDragged },
{ kEventClassWindow, kEventWindowClose },
{ kEventClassWindow, kEventWindowDrawContent },
{ kEventClassWindow, kEventWindowBoundsChanged }
};
InstallWindowEventHandler(_pLocalWindow, _pEventHandler,
GetEventTypeCount(eventList),
eventList, this, 0);
aglSetWindowRef(_pContext, _pLocalWindow);
_pCarbWindow = pCarbonWindow;
_pCarbWindow->setContext(_pContext);
_pCarbWindow->init ( );
_pCarbWindow->resize ( uiWidth,
uiHeight);
std::string windowName(" OpenSG - CSM - ");
_pCarbWindow->activate();
windowName += reinterpret_cast<const char *>(glGetString(GL_VERSION));
windowName += " - ";
windowName += reinterpret_cast<const char *>(glGetString(GL_RENDERER));
_pCarbWindow->deactivate();
SetWTitle(_pLocalWindow,
reinterpret_cast<const unsigned char *>(windowName.c_str()));
// Show window
RepositionWindow(_pLocalWindow, 0, kWindowCascadeOnMainScreen);
ShowWindow (_pLocalWindow );
if(ComplexSceneManager::the() != NULL)
ComplexSceneManager::the()->setMainloop(
&CSMNativeWindow::carbonMainLoop);
_pWindow = _pCarbWindow;
_bRun = true;
Inherited::init();
return true;
}
static AGLContext createContext(WindowRef window) {
AGLPixelFormat pf;
AGLContext ctx;
GDHandle gdh;
CFDictionaryRef refMode;
GLenum error;
CGDirectDisplayID mainDisplay = CGMainDisplayID();
GLint attrs[] = {
AGL_RGBA,
AGL_DOUBLEBUFFER,
AGL_RED_SIZE, 4,
AGL_GREEN_SIZE, 4,
AGL_BLUE_SIZE, 4,
AGL_DEPTH_SIZE, 16,
AGL_NONE
};
GLint fullscreen_attrs[] = {
AGL_FULLSCREEN,
AGL_RGBA,
AGL_DOUBLEBUFFER,
AGL_RED_SIZE, 4,
AGL_GREEN_SIZE, 4,
AGL_BLUE_SIZE, 4,
AGL_DEPTH_SIZE, 16,
AGL_NONE
};
g_Window.double_buffered = true;
if (!g_Window.fs) {
pf = aglChoosePixelFormat(NULL, 0, attrs);
} else {
CGDisplayCapture(mainDisplay);
refMode = CGDisplayBestModeForParameters(mainDisplay, 32,
g_Window.width, g_Window.height, NULL);
CGDisplaySwitchToMode(mainDisplay, refMode);
DMGetGDeviceByDisplayID(mainDisplay, &gdh, false);
pf = aglChoosePixelFormat(&gdh, 1, fullscreen_attrs);
error = aglGetError();
if (error != AGL_NO_ERROR) {
printf("%s\n", aglErrorString(error));
return 0;
}
}
if (!pf) {
printf("Error choosing pixel format\n");
return 0;
}
ctx = aglCreateContext(pf, 0);
if (!ctx) {
printf("%s\n", aglErrorString(aglGetError()));
return 0;
}
aglDestroyPixelFormat(pf);
aglSetCurrentContext(ctx);
if (g_Window.fs) {
aglSetFullScreen(ctx, g_Window.width, g_Window.height, 0, 0);
} else {
aglSetWindowRef(ctx, window);
}
return ctx;
}
