glXIntro man page on SunOS

Man page or keyword search:  
man Server   20652 pages
apropos Keyword Search (all sections)
Output format
SunOS logo
[printable version]

GLXINTRO(3gl)							 GLXINTRO(3gl)

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

       static int attributeListDbl[] = {
	    GLX_RGBA,
	    GLX_DOUBLEBUFFER, /*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 = GL_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 = GL_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);
       }

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 buf‐
       fers 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, glFinish, glFlush, glXChooseVisual, glXCopyContext,
       glXCreateContext, glXCreateGLXPixmap, glXDestroyContext,
       glXGetClientString, glXGetConfig, glXIsDirect, glXMakeCurrent,
       glXQueryExtension, glXQueryExtensionsString, glXQueryServerString, glX‐
       QueryVersion,  glXSwapBuffers,  glXUseXFont, glXWaitGL, glXWaitX, XCre‐
       ateColormap, XCreateWindow, XSync

				   21 Aug 97			 GLXINTRO(3gl)
[top]

List of man pages available for SunOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net