The OpenNET Project / Index page

[ новости /+++ | форум | теги | ]

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

glxintro (3)
  • >> glxintro (3) ( Solaris man: Библиотечные вызовы )
  • 
    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 ver-
         sion is supported, call glXQueryExtension  and  glXQueryVer-
         sion.
    
         GLX extended servers make a subset of their  visuals  avail-
         able  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 compati-
         ble with all core X visuals.
    
         GLX extends drawables with several buffers  other  than  the
         standard color buffer.  These buffers include back and auxi-
         liary 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 compati-
         ble  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 draw-
         able 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.
    
    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 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.
    
    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.
    
    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,  glXQuer-
         yServerString, 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  sup-
         ported.
    
    SEE ALSO
         glIntro, glFinish, glFlush, glXChooseVisual, glXCopyContext,
         glXCreateContext, glXCreateGLXPixmap, glXDestroyContext,
         glXGetClientString,        glXGetConfig,        glXIsDirect,
         glXMakeCurrent,
         glXQueryExtension, glXQueryExtensionsString, glXQueryServer-
         String,    glXQueryVersion,   glXSwapBuffers,   glXUseXFont,
         glXWaitGL, glXWaitX, XCreateColormap, XCreateWindow, XSync
    
    
    
    


    Поиск по тексту MAN-ов: 




    Партнёры:
    PostgresPro
    Inferno Solutions
    Hosting by Hoster.ru
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2024 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру