src/x11/glcanvas.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        glcanvas.cpp
   3 // Purpose:     wxGLCanvas, for using OpenGL with wxWindows
   4 //              Uses the GLX extension.
   5 // Author:      Julian Smart and Wolfram Gloger
   6 // Modified by:
   7 // Created:     1995, 1999
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) Julian Smart, Wolfram Gloger
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  14 #pragma implementation "glcanvas.h"
  15 #endif
  16
  17 #include "wx/setup.h"
  18
  19 #if wxUSE_GLCANVAS
  20
  21 #include "wx/glcanvas.h"
  22 #include "wx/utils.h"
  23 #include "wx/app.h"
  24 #include "wx/log.h"
  25
  26 #ifdef __VMS
  27 # pragma message disable nosimpint
  28 #endif
  29 #include <X11/Xlib.h>
  30 #ifdef __VMS
  31 # pragma message enable nosimpint
  32 #endif
  33 #include "wx/x11/private.h"
  34
  35 // DLL options compatibility check:
  36 #include "wx/build.h"
  37 WX_CHECK_BUILD_OPTIONS("wxGL")
  38
  39 static inline WXWindow wxGetClientAreaWindow(wxWindow* win)
  40 {
  41 #ifdef __WXMOTIF__
  42     return win->GetClientXWindow();
  43 #else
  44     return win->GetClientAreaWindow();
  45 #endif
  46 }
  47
  48 #ifdef OLD_MESA
  49 // workaround for bug in Mesa's glx.c
  50 static int bitcount( unsigned long n )
  51 {
  52     int bits;
  53     for (bits=0; n>0;) {
  54         if(n & 1) bits++;
  55         n = n >> 1;
  56     }
  57     return bits;
  58 }
  59 #endif
  60
  61 /*
  62  * GLContext implementation
  63  */
  64
  65 IMPLEMENT_CLASS(wxGLContext,wxObject)
  66
  67 wxGLContext::wxGLContext( bool WXUNUSED(isRGB), wxWindow *win,
  68                           const wxPalette& WXUNUSED(palette) )
  69 {
  70     m_window = win;
  71     // m_widget = win->m_wxwindow;
  72
  73     wxGLCanvas *gc = (wxGLCanvas*) win;
  74     XVisualInfo *vi = (XVisualInfo *) gc->m_vi;
  75
  76     wxCHECK_RET( vi, wxT("invalid visual for OpenGL") );
  77
  78     m_glContext = glXCreateContext( (Display *)wxGetDisplay(), vi,
  79                                     None, GL_TRUE);
  80
  81     wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
  82 }
  83
  84 wxGLContext::wxGLContext(
  85                bool WXUNUSED(isRGB), wxWindow *win,
  86                const wxPalette& WXUNUSED(palette),
  87                const wxGLContext *other        /* for sharing display lists */
  88 )
  89 {
  90     m_window = win;
  91     // m_widget = win->m_wxwindow;
  92
  93     wxGLCanvas *gc = (wxGLCanvas*) win;
  94     XVisualInfo *vi = (XVisualInfo *) gc->m_vi;
  95
  96     wxCHECK_RET( vi, wxT("invalid visual for OpenGL") );
  97
  98     if( other != 0 )
  99         m_glContext = glXCreateContext( (Display *)wxGetDisplay(), vi,
 100                                         other->m_glContext, GL_TRUE );
 101     else
 102         m_glContext = glXCreateContext( (Display *)wxGetDisplay(), vi,
 103                                         None, GL_TRUE );
 104
 105     wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
 106 }
 107
 108 wxGLContext::~wxGLContext()
 109 {
 110     if (!m_glContext) return;
 111
 112     if (m_glContext == glXGetCurrentContext())
 113     {
 114         glXMakeCurrent( (Display*) wxGetDisplay(), None, NULL);
 115     }
 116
 117     glXDestroyContext( (Display*) wxGetDisplay(), m_glContext );
 118 }
 119
 120 void wxGLContext::SwapBuffers()
 121 {
 122     if (m_glContext)
 123     {
 124         Display* display = (Display*) wxGetDisplay();
 125         glXSwapBuffers(display, (Window) wxGetClientAreaWindow(m_window));
 126     }
 127 }
 128
 129 void wxGLContext::SetCurrent()
 130 {
 131     if (m_glContext)
 132     {
 133         Display* display = (Display*) wxGetDisplay();
 134         glXMakeCurrent(display, (Window) wxGetClientAreaWindow(m_window),
 135                        m_glContext );;
 136     }
 137 }
 138
 139 void wxGLContext::SetColour(const wxChar *colour)
 140 {
 141     wxColour *the_colour = wxTheColourDatabase->FindColour(colour);
 142     if(the_colour) {
 143         GLboolean b;
 144         glGetBooleanv(GL_RGBA_MODE, &b);
 145         if(b) {
 146             glColor3ub(the_colour->Red(),
 147                        the_colour->Green(),
 148                        the_colour->Blue());
 149         } else {
 150 #ifdef __WXMOTIF__
 151             the_colour->AllocColour(m_window->GetXDisplay());
 152 #else
 153             the_colour->CalcPixel(wxTheApp->GetMainColormap(wxGetDisplay()));
 154 #endif
 155             GLint pix = (GLint)the_colour->GetPixel();
 156             if(pix == -1)
 157             {
 158                 wxLogError(wxT("wxGLCanvas: cannot allocate color\n"));
 159                 return;
 160             }
 161             glIndexi(pix);
 162         }
 163     }
 164 }
 165
 166 void wxGLContext::SetupPixelFormat()
 167 {
 168 }
 169
 170 void wxGLContext::SetupPalette( const wxPalette& WXUNUSED(palette) )
 171 {
 172 }
 173
 174 wxPalette wxGLContext::CreateDefaultPalette()
 175 {
 176     return wxNullPalette;
 177 }
 178
 179
 180
 181
 182 /*
 183  * GLCanvas implementation
 184  */
 185
 186 IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)
 187
 188 BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
 189 //    EVT_SIZE(wxGLCanvas::OnSize)
 190 END_EVENT_TABLE()
 191
 192
 193 wxGLCanvas::wxGLCanvas( wxWindow *parent, wxWindowID id,
 194                         const wxPoint& pos, const wxSize& size,
 195                         long style, const wxString& name,
 196                         int *attribList,
 197                         const wxPalette& palette )
 198 : wxScrolledWindow(parent, id, pos, size, style, name)
 199 {
 200     Create( parent, NULL, NULL, id, pos, size, style, name, attribList, palette );
 201 }
 202
 203 wxGLCanvas::wxGLCanvas( wxWindow *parent,
 204                         const wxGLContext *shared,
 205                         wxWindowID id,
 206                         const wxPoint& pos, const wxSize& size,
 207                         long style, const wxString& name,
 208                         int *attribList,
 209                         const wxPalette& palette )
 210 : wxScrolledWindow(parent, id, pos, size, style, name)
 211 {
 212     Create( parent, shared, NULL, id, pos, size, style, name, attribList, palette );
 213 }
 214
 215 wxGLCanvas::wxGLCanvas( wxWindow *parent,
 216                         const wxGLCanvas *shared,
 217                         wxWindowID id,
 218                         const wxPoint& pos, const wxSize& size,
 219                         long style, const wxString& name,
 220                         int *attribList,
 221                         const wxPalette& palette )
 222 : wxScrolledWindow(parent, id, pos, size, style, name)
 223 {
 224     Create( parent, NULL, shared, id, pos, size, style, name, attribList, palette );
 225 }
 226
 227
 228 /*
 229 bool wxGLCanvas::Create(wxWindow *parent,
 230   const wxGLContext *shared, const wxGLCanvas *shared_context_of,
 231   wxWindowID id = -1, const wxPoint& pos,
 232   const wxSize& size, long style,
 233   const wxString& name, int *attribList, const wxPalette& palette):
 234     wxScrolledWindow(parent, id, pos, size, style, name)
 235 */
 236
 237 bool wxGLCanvas::Create( wxWindow *parent,
 238                          const wxGLContext *shared,
 239                          const wxGLCanvas *shared_context_of,
 240                          wxWindowID id,
 241                          const wxPoint& pos, const wxSize& size,
 242                          long style, const wxString& name,
 243                          int *attribList,
 244                          const wxPalette& palette)
 245 {
 246     XVisualInfo *vi, vi_templ;
 247     XWindowAttributes xwa;
 248     int val, n;
 249
 250     m_sharedContext = (wxGLContext*)shared;  // const_cast
 251     m_sharedContextOf = (wxGLCanvas*)shared_context_of;  // const_cast
 252     m_glContext = (wxGLContext*) NULL;
 253
 254     Display* display = (Display*) wxGetDisplay();
 255
 256     // Check for the presence of the GLX extension
 257     if(!glXQueryExtension(display, NULL, NULL)) {
 258         wxLogDebug(wxT("wxGLCanvas: GLX extension is missing\n"));
 259         return FALSE;
 260     }
 261
 262     if(attribList) {
 263       int data[512], arg=0, p=0;
 264
 265       while( (attribList[arg]!=0) && (p<512) )
 266       {
 267         switch( attribList[arg++] )
 268         {
 269           case WX_GL_RGBA: data[p++] = GLX_RGBA; break;
 270           case WX_GL_BUFFER_SIZE:
 271             data[p++]=GLX_BUFFER_SIZE; data[p++]=attribList[arg++]; break;
 272           case WX_GL_LEVEL:
 273             data[p++]=GLX_LEVEL; data[p++]=attribList[arg++]; break;
 274           case WX_GL_DOUBLEBUFFER: data[p++] = GLX_DOUBLEBUFFER; break;
 275           case WX_GL_STEREO: data[p++] = GLX_STEREO; break;
 276           case WX_GL_AUX_BUFFERS:
 277             data[p++]=GLX_AUX_BUFFERS; data[p++]=attribList[arg++]; break;
 278           case WX_GL_MIN_RED:
 279             data[p++]=GLX_RED_SIZE; data[p++]=attribList[arg++]; break;
 280           case WX_GL_MIN_GREEN:
 281             data[p++]=GLX_GREEN_SIZE; data[p++]=attribList[arg++]; break;
 282           case WX_GL_MIN_BLUE:
 283             data[p++]=GLX_BLUE_SIZE; data[p++]=attribList[arg++]; break;
 284           case WX_GL_MIN_ALPHA:
 285             data[p++]=GLX_ALPHA_SIZE; data[p++]=attribList[arg++]; break;
 286           case WX_GL_DEPTH_SIZE:
 287             data[p++]=GLX_DEPTH_SIZE; data[p++]=attribList[arg++]; break;
 288           case WX_GL_STENCIL_SIZE:
 289             data[p++]=GLX_STENCIL_SIZE; data[p++]=attribList[arg++]; break;
 290           case WX_GL_MIN_ACCUM_RED:
 291             data[p++]=GLX_ACCUM_RED_SIZE; data[p++]=attribList[arg++]; break;
 292           case WX_GL_MIN_ACCUM_GREEN:
 293             data[p++]=GLX_ACCUM_GREEN_SIZE; data[p++]=attribList[arg++]; break;
 294           case WX_GL_MIN_ACCUM_BLUE:
 295             data[p++]=GLX_ACCUM_BLUE_SIZE; data[p++]=attribList[arg++]; break;
 296           case WX_GL_MIN_ACCUM_ALPHA:
 297             data[p++]=GLX_ACCUM_ALPHA_SIZE; data[p++]=attribList[arg++]; break;
 298           default:
 299             break;
 300         }
 301       }
 302       data[p] = 0;
 303
 304       attribList = (int*) data;
 305       // Get an appropriate visual
 306       vi = glXChooseVisual(display, DefaultScreen(display), attribList);
 307       if(!vi) return FALSE;
 308
 309       // Here we should make sure that vi is the same visual as the
 310       // one used by the xwindow drawable in wxCanvas.  However,
 311       // there is currently no mechanism for this in wx_canvs.cc.
 312     } else {
 313         // By default, we use the visual of xwindow
 314         // NI: is this really senseful ? opengl in e.g. color index mode ?
 315         XGetWindowAttributes(display, (Window)wxGetClientAreaWindow(this), &xwa);
 316         vi_templ.visualid = XVisualIDFromVisual(xwa.visual);
 317         vi = XGetVisualInfo(display, VisualIDMask, &vi_templ, &n);
 318         if(!vi) return FALSE;
 319         glXGetConfig(display, vi, GLX_USE_GL, &val);
 320         if(!val) return FALSE;
 321         // Basically, this is it.  It should be possible to use vi
 322         // in glXCreateContext() below.  But this fails with Mesa.
 323         // I notified the Mesa author about it; there may be a fix.
 324 #ifdef OLD_MESA
 325         // Construct an attribute list matching the visual
 326         int a_list[32];
 327         n = 0;
 328         if(vi->c_class==TrueColor || vi->c_class==DirectColor) { // RGBA visual
 329             a_list[n++] = GLX_RGBA;
 330             a_list[n++] = GLX_RED_SIZE;
 331             a_list[n++] = bitcount(vi->red_mask);
 332             a_list[n++] = GLX_GREEN_SIZE;
 333             a_list[n++] = bitcount(vi->green_mask);
 334             a_list[n++] = GLX_BLUE_SIZE;
 335             a_list[n++] = bitcount(vi->blue_mask);
 336             glXGetConfig(display, vi, GLX_ALPHA_SIZE, &val);
 337             a_list[n++] = GLX_ALPHA_SIZE;
 338             a_list[n++] = val;
 339         } else { // Color index visual
 340             glXGetConfig(display, vi, GLX_BUFFER_SIZE, &val);
 341             a_list[n++] = GLX_BUFFER_SIZE;
 342             a_list[n++] = val;
 343         }
 344         a_list[n] = None;
 345         // XFree(vi);
 346         vi = glXChooseVisual(display, DefaultScreen(display), a_list);
 347         if(!vi) return FALSE;
 348 #endif /* OLD_MESA */
 349     }
 350
 351     m_vi = vi;  // safe for later use
 352
 353     wxCHECK_MSG( m_vi, FALSE, wxT("required visual couldn't be found") );
 354
 355     // Create the GLX context and make it current
 356
 357     wxGLContext *share= m_sharedContext;
 358     if (share==NULL && m_sharedContextOf)
 359         share = m_sharedContextOf->GetContext();
 360
 361     m_glContext = new wxGLContext( TRUE, this, wxNullPalette, share );
 362
 363 #ifndef OLD_MESA
 364     // XFree(vi);
 365 #endif
 366     SetCurrent();
 367
 368     return TRUE;
 369 }
 370
 371 wxGLCanvas::~wxGLCanvas(void)
 372 {
 373     XVisualInfo *vi = (XVisualInfo *) m_vi;
 374
 375     if (vi) XFree( vi );
 376     if (m_glContext) delete m_glContext;
 377
 378     // Display* display = (Display*) GetXDisplay();
 379     // if(glx_cx) glXDestroyContext(display, glx_cx);
 380 }
 381
 382 void wxGLCanvas::SwapBuffers()
 383 {
 384     if( m_glContext ) m_glContext->SwapBuffers();
 385
 386     // Display* display = (Display*) GetXDisplay();
 387     // if(glx_cx) glXSwapBuffers(display, (Window) GetClientAreaWindow());
 388 }
 389
 390 void wxGLCanvas::SetCurrent()
 391 {
 392     if( m_glContext ) m_glContext->SetCurrent();
 393
 394     // Display* display = (Display*) GetXDisplay();
 395     // if(glx_cx) glXMakeCurrent(display, (Window) GetClientAreaWindow(), glx_cx);
 396 }
 397
 398 void wxGLCanvas::SetColour(const wxChar *col)
 399 {
 400     if( m_glContext ) m_glContext->SetColour(col);
 401 }
 402
 403 #endif
 404     // wxUSE_GLCANVAS
 405