Index Index for
Section 3
Index Alphabetical
listing for G
Bottom of page Bottom of
page		 

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 created
  with either XCreateWindow() or glXCreateGLXPixmap(). Finally, bind the
  context and the drawable together using glXMakeCurrent(). This
  context/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, however,
  except at explicitly created boundaries generated by calling glXWaitGL(),
  glXWaitX(), XSync(), and glFlush().


USING GLX EXTENSIONS

  All supported GLX extensions will have a corresponding definition in glx.h
  and a token in the extension string returned by glXQueryExtensionsString().
  For example, if the EXT_visual_info extension is supported, then this token
  will be defined in glx.h and EXT_visual_info will appear in the extension
  string returned by glXQueryExtensionsString(). The definitions in glx.h can
  be used at compile time to determine if procedure calls corresponding to an
  extension exist in the library.

  OpenGL itself has also been extended. Refer to glIntro() for more
  information.


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, /*get the deepest buffer with 1 red bit*/
	   GLX_GREEN_SIZE, 1,
	   GLX_BLUE_SIZE,  1,
	   None };

       static int attributeListDbl[] = {
	   GLX_RGBA,
	   GLX_DOUBLE_BUFFER, /*In case single buffering is not supported*/
	   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;

	   /* get a connection */
	   dpy = XOpenDisplay(0);

	   /* get an appropriate visual */
	   vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeListSgl);
	   if (vi == NULL) {
	      vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeListDbl);
	      swap_flag = TRUE;
	   }

	   /* create a GLX context */
	   cx = glXCreateContext(dpy, vi, 0, GL_TRUE);

	   /* create a color map */
	   cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
		      vi->visual, AllocNone);

	   /* create a window */
	   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);

	   /* connect the context to the window */
	   glXMakeCurrent(dpy, win, cx);

	   /* clear the buffer */
	   glClearColor(1,1,0,1);
	   glClear(GL_COLOR_BUFFER_BIT);
	   glFlush();
	   if (swap_flag) glXSwapBuffers(dpy,win);

	   /* wait a while */
	   sleep(10);
       }


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
  glXGetClientString().

  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_VERSION_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.


NOTES

  A color map must be created and passed to XCreateWindow.  See the preceding
  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 context/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, visualID,
  screen, and depth elements, as well as other X-specific information.


SEE ALSO

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

Index Index for
Section 3
Index Alphabetical
listing for G
Top of page Top of
page