manpagez: man pages & more
man glXIntro(3)
Home | html | info | man
GLXINTRO()                                                          GLXINTRO()




NAME

       glXIntro - Introduction to OpenGL in the X window system



OVERVIEW

       OpenGL  (called  GL  in  other pages) is a high-performance 3D-oriented
       renderer.  It is available in the  X  window  system  through  the  GLX
       extension.  To determine whether the GLX extension is supported by an X
       server, and if so, what version is  supported,  call  glXQueryExtension
       and glXQueryVersion.

       GLX  extended  servers  make  a  subset  of their visuals available for
       OpenGL rendering.  Drawables created with these  visuals  can  also  be
       rendered using the core X renderer and with the renderer of any other X
       extension that is compatible with all core X visuals.

       GLX extends drawables with several  buffers  other  than  the  standard
       color  buffer.  These buffers include back and auxiliary color buffers,
       a depth buffer, a stencil buffer,  and  a  color  accumulation  buffer.
       Some or all are included in each X visual that supports OpenGL.

       To  render  using  OpenGL  into  an X drawable, you must first choose a
       visual that defines the required OpenGL buffers.   glXChooseVisual  can
       be  used to simplify selecting a compatible visual.  If more control of
       the selection process is required, use XGetVisualInfo and  glXGetConfig
       to select among all the available visuals.

       Use the selected visual to create both a GLX context and an X drawable.
       GLX contexts are created with glXCreateContext, and drawables are  cre-
       ated  with  either  XCreateWindow or glXCreateGLXPixmap.  Finally, bind
       the context and the drawable together using glXMakeCurrent.  This  con-
       text/drawable  pair  becomes  the current context and current drawable,
       and it is used by all OpenGL commands until  glXMakeCurrent  is  called
       with different arguments.

       Both  core  X and OpenGL commands can be used to operate on the current
       drawable.  The X and OpenGL command streams are not synchronized,  how-
       ever,  except  at  explicitly  created  boundaries generated by calling
       glXWaitGL, glXWaitX, XSync, and glFlush.


EXAMPLES

       Below is the minimum code required to create an RGBA-format,  X  window
       that's  compatible  with OpenGL and to clear it to yellow.  The code is
       correct, but it does not include any  error  checking.   Return  values
       dpy, vi, cx, cmap, and win should all be tested.

       #include <GL/glx.h> #include <GL/gl.h> #include <unistd.h>

       static  int  attributeListSgl[]  =  {      GLX_RGBA,      GLX_RED_SIZE,
       1,      GLX_GREEN_SIZE, 1,      GLX_BLUE_SIZE,  1,      None };

       static  int  attributeListDbl[]  =   {        GLX_RGBA,        GLX_DOU-
       BLE_BUFFER,         GLX_RED_SIZE,      1,         GLX_GREEN_SIZE,    1,
            GLX_BLUE_SIZE,  1,      None };


       static Bool WaitForNotify(Display *d, XEvent *e, char *arg) {
           return (e->type == MapNotify) && (e->xmap.window == (Window)arg); }

       int main(int argc, char **argv) {
           Display *dpy;
           XVisualInfo *vi;
           Colormap cmap;
           XSetWindowAttributes swa;
           Window win;
           GLXContext cx;
           XEvent event;
           int swap_flag = FALSE;



           dpy = XOpenDisplay(0);


           vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeListSgl);
           if (vi == NULL) {
              vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeListDbl);
              swap_flag = TRUE;
           }


           cx = glXCreateContext(dpy, vi, 0, GL_TRUE);


           cmap   =    XCreateColormap(dpy,    RootWindow(dpy,    vi->screen),
                         vi->visual, AllocNone);


           swa.colormap = cmap;
           swa.border_pixel = 0;
           swa.event_mask = StructureNotifyMask;
           win  =  XCreateWindow(dpy,  RootWindow(dpy, vi->screen), 0, 0, 100,
       100,
                               0, vi->depth, InputOutput, vi->visual,
                               CWBorderPixel|CWColormap|CWEventMask, &swa);
           XMapWindow(dpy, win);
           XIfEvent(dpy, &event, WaitForNotify, (char*)win);


           glXMakeCurrent(dpy, win, cx);


           glClearColor(1,1,0,1);
           glClear(GL_COLOR_BUFFER_BIT);
           glFlush();
           if (swap_flag) glXSwapBuffers(dpy,win);


           sleep(10); }


NOTES

       A color map must be created and passed to XCreateWindow.  See the  pre-
       ceding example code.

       A  GLX  context  must  be  created and attached to an X drawable before
       OpenGL commands can be executed.  OpenGL commands issued while no  con-
       text/drawable pair is current result in undefined behavior.

       Exposure events indicate that all buffers associated with the specified
       window may be  damaged  and  should  be  repainted.   Although  certain
       buffers  of  some  visuals on some systems may never require repainting
       (the depth buffer, for example), it is incorrect  to  write  a  program
       assuming that these buffers will not be damaged.

       GLX  commands manipulate XVisualInfo structures rather than pointers to
       visuals or visual IDs.  XVisualInfo structures  contain  visual,  visu-
       alID,  screen, and depth elements, as well as other X-specific informa-
       tion.


USING GLX EXTENSIONS

       All supported GLX extensions will have a  corresponding  definition  in
       glx.h  and  a  token in the extension string returned by glXQueryExten-
       sionsString.  For example, if the  EXT_visual_info  extension  is  sup-
       ported,  then  this  token will be defined in glx.h and EXT_visual_info
       will appear in the  extension  string  returned  by  glXQueryExtension-
       sString. The definitions in glx.h can be used at compile time to deter-
       mine if procedure calls corresponding to  an  extension  exist  in  the
       library.

       OpenGL  itself has also been extended. Refer to glIntro for more infor-
       mation.



GLX 1.1 and GLX 1.2

       GLX 1.2 is now supported. It is backward compatible with  GLX  1.1  and
       GLX 1.0.

       GLX  1.2 corresponds to OpenGL version 1.1 and introduces the following
       new call: glGetCurrentDisplay.

       GLX 1.1 corresponds to OpenGL version 1.0 and introduces the  following
       new  calls: glXQueryExtensionsString, glXQueryServerString, and glXGet-
       ClientString.

       Call glQueryVersion to determine at runtime  what  version  of  GLX  is
       available.  glQueryVersion returns the version that is supported on the
       connection. Thus if 1.2 is returned, both the client and server support
       GLX  1.2.  You can also check the GLX version at compile time: GLX_VER-
       SION_1_1 will be defined in glx.h if GLX 1.1 calls  are  supported  and
       GLX_VERSION_1_2 will be defined if GLX 1.2 calls are supported.


SEE ALSO

       glIntro(3), glFinish(3), glFlush(3), glXChooseVisual(3),
       glXCopyContext(3), glXCreateContext(3), glXCreateGLXPixmap(3),
       glXDestroyContext(3), glXGetClientString(3), glXGetConfig(3),
       glXIsDirect(3), glXMakeCurrent(3), glXQueryExtension(3),
       glXQueryExtensionsString(3), glXQueryServerString(3), glXQueryVersion(3),
       glXSwapBuffers(3), glXUseXFont(3), glXWaitGL(3),  glXWaitX(3),
       XCreateColormap(3), XCreateWindow(3), XSync(3)











                                                                    GLXINTRO()

Mac OS X 10.4 X11 - Generated Sat Apr 30 05:14:16 CDT 2005
© manpagez.com 2000-2024
Individual documents may contain additional copyright information.