Attachment 22487 Details for Bug 19910 – Test case

Test case

tfp-blend.c (text/plain), 10.21 KB, created by Neil Roberts on 2009-02-02 08:56:27 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Neil Roberts

Created: 2009-02-02 08:56:27 UTC

Size: 10.21 KB

patch

obsolete

>#include <stdio.h>
>#include <stdlib.h>
>#include <string.h>
>#include <unistd.h>
>#include <GL/gl.h>
>#include <GL/glx.h>
>#include <X11/Xlib.h>
>#include <X11/extensions/Xcomposite.h>
>#include <errno.h>
>
>typedef struct _Data Data;
>
>typedef void (* BindTexImageFunc) (Display     *display,
>                                   GLXDrawable  drawable,
>                                   int          buffer,
>                                   int         *attribList);
>typedef void (* ReleaseTexImageFunc) (Display     *display,
>                                      GLXDrawable  drawable,
>                                      int          buffer);
>
>struct _Data
>{
>  Display *dpy;
>  Window w;
>  GLXContext ctx;
>  GLXPixmap glx_pixmap;
>  Pixmap win_pixmap;
>  Window sub_win;
>
>  BindTexImageFunc bind_tex_image;
>  ReleaseTexImageFunc release_tex_image;
>
>  GLuint rgb_tex_num, alpha_tex_num;
>};
>
>#define TEX_WIDTH  2
>#define TEX_HEIGHT 2
>
>#define PIXMAP_WIDTH  128
>#define PIXMAP_HEIGHT 128
>
>/* 4x4 pure alpha texture with all full alpha except bottom left pixel */
>static const GLubyte alpha_tex_data[]
>= { 0x80, 0xff, 0xff, 0xff };
>
>static void
>redraw (Data *data)
>{
>  GLfloat tex_coords[] =
>    {
>      0.0f, 0.0f,
>      1.0f, 0.0f,
>      0.0f, 1.0f,
>      1.0f, 1.0f
>    };
>  GLfloat vertex_coords[] =
>    {
>      -1.0, -1.0,
>      1.0, -1.0,
>      -1.0, 1.0,
>      1.0, 1.0
>    };
>
>  if (data->glx_pixmap != None)
>    {
>      /* Bind the pixmap to the rgb texture in the first layer */
>      glActiveTexture (GL_TEXTURE0);
>      glBindTexture (GL_TEXTURE_2D, data->rgb_tex_num);
>      data->bind_tex_image (data->dpy, data->glx_pixmap, GLX_FRONT_LEFT_EXT, NULL);
>    }
>
>  glClear (GL_COLOR_BUFFER_BIT);
>
>  glColor4f (1.0f, 1.0f, 1.0f, 1.0f);
>
>  glEnableClientState (GL_VERTEX_ARRAY);
>  glVertexPointer (2, GL_FLOAT, 0, vertex_coords);
>
>  glClientActiveTexture (GL_TEXTURE0);
>  glEnableClientState (GL_TEXTURE_COORD_ARRAY);
>  glTexCoordPointer (2, GL_FLOAT, 0, tex_coords);
>
>  glClientActiveTexture (GL_TEXTURE1);
>  glEnableClientState (GL_TEXTURE_COORD_ARRAY);
>  glTexCoordPointer (2, GL_FLOAT, 0, tex_coords);
>
>  glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
>
>  glXSwapBuffers (data->dpy, data->w);
>
>  if (data->glx_pixmap != None)
>    data->release_tex_image (data->dpy, data->glx_pixmap, GLX_FRONT_LEFT_EXT);
>}
>
>static GLuint
>make_tex (const GLubyte *data,
>          int width, int height,
>          GLenum format, GLenum internal_format)
>{
>  GLuint tex_num;
>
>  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
>
>  glGenTextures (1, &tex_num);
>  glBindTexture (GL_TEXTURE_2D, tex_num);
>  glTexImage2D (GL_TEXTURE_2D, 0, internal_format,
>                width, height, 0,
>                format, GL_UNSIGNED_BYTE, data);
>
>  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
>  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
>  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
>  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
>
>  glEnable (GL_TEXTURE_2D);
>
>  return tex_num;
>}
>
>static Window
>make_window (Data *data, unsigned int width, unsigned int height)
>{
>  int attrib[] =
>    {
>      GLX_RGBA,
>      GLX_RED_SIZE, 1,
>      GLX_GREEN_SIZE, 1,
>      GLX_BLUE_SIZE, 1,
>      GLX_DOUBLEBUFFER,
>      None
>    };
>  int scrnum = 0;
>  XSetWindowAttributes attr;
>  unsigned long mask;
>  Window root;
>  Window win;
>  XVisualInfo *visinfo;
>
>  root = RootWindow (data->dpy, scrnum);
>
>  if (!(visinfo = glXChooseVisual (data->dpy, scrnum, attrib)))
>    {
>      printf ("Error: couldn't get an RGB, Double-buffered visual\n");
>      exit (1);
>    }
>
>  if (!(data->ctx = glXCreateContext (data->dpy, visinfo, NULL, True)))
>    {
>      printf ("Error: glXCreateContext failed\n");
>      exit (1);
>    }
>
>  /* window attributes */
>  attr.background_pixel = 0;
>  attr.border_pixel = 0;
>  attr.colormap = XCreateColormap (data->dpy, root, visinfo->visual, AllocNone);
>  attr.event_mask = StructureNotifyMask | ExposureMask
>    | PointerMotionMask | KeyPressMask;
>  mask = CWBorderPixel | CWColormap | CWEventMask;
>
>  win = XCreateWindow (data->dpy, root, 0, 0, width, height,
>		       0, visinfo->depth, InputOutput,
>		       visinfo->visual, mask, &attr);
>  if (!win)
>    {
>      printf ("Error: XCreateWindow failed\n");
>      exit (1);
>    }
>
>  glXMakeCurrent (data->dpy, win, data->ctx);
>
>  data->rgb_tex_num = make_tex (NULL, PIXMAP_WIDTH, PIXMAP_HEIGHT,
>                                GL_RGB, GL_RGB);
>
>  glActiveTexture (GL_TEXTURE1);
>  data->alpha_tex_num = make_tex (alpha_tex_data, TEX_WIDTH, TEX_HEIGHT,
>                                  GL_ALPHA, GL_ALPHA);
>
>  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
>
>  /* Replace the RGB from layer 1 with the RGB from layer 0 */
>  glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
>  glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);
>
>  if (getenv ("WORKAROUND"))
>    {
>      /* workaround */
>
>      /* Use the alpha from layer 1 modulated with the alpha from the
>         primary color */
>      glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
>      glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR);
>      glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE);
>    }
>  else
>    {
>      /* not workaround */
>
>      /* Modulate the alpha in layer 1 with the alpha from the
>         previous layer */
>      glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
>      glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS);
>      glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE);
>    }
>
>  glViewport (0, 0, width, height);
>
>  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
>
>  glEnable (GL_BLEND);
>
>  return win;
>}
>
>static Pixmap
>composite_window (Display *display, Window win)
>{
>  XCompositeRedirectWindow (display, win, CompositeRedirectAutomatic);
>  return XCompositeNameWindowPixmap (display, win);
>}
>
>static void
>uncomposite_window (Display *display, Window win, Pixmap pixmap)
>{
>  XFreePixmap (display, pixmap);
>  XCompositeUnredirectWindow (display, win, CompositeRedirectAutomatic);
>}
>
>static GLXPixmap
>create_glx_pixmap (Display *display, Drawable draw)
>{
>  static const int fb_config_attribs[] =
>    {
>      GLX_RENDER_TYPE, GLX_RGBA_BIT,
>      GLX_RED_SIZE, 8,
>      GLX_GREEN_SIZE, 8,
>      GLX_BLUE_SIZE, 8,
>      GLX_ALPHA_SIZE, 0,
>      GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
>      GLX_BIND_TO_TEXTURE_RGB_EXT, 1,
>      None
>    };
>  static const int pixmap_attribs[] =
>    {
>      GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
>      GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
>      None
>    };
>  GLXFBConfig *fb_configs;
>  int n_fb_configs = 0;
>  GLXPixmap glx_pixmap = None;
>
>  fb_configs = glXChooseFBConfig (display, DefaultScreen (display),
>                                  fb_config_attribs, &n_fb_configs);
>
>  if (fb_configs == NULL || n_fb_configs < 1)
>    fprintf (stderr, "No valid FB config found\n");
>  else
>    glx_pixmap = glXCreatePixmap (display, fb_configs[n_fb_configs - 1],
>                                  draw, pixmap_attribs);
>
>  if (fb_configs)
>    XFree (fb_configs);
>
>  return glx_pixmap;
>}
>
>static void
>draw_to_window (Display *display, Window win)
>{
>  GC white_gc, black_gc;
>  XGCValues gc_values;
>  unsigned long white, black;
>
>  white = WhitePixel (display, DefaultScreen (display));
>  black = BlackPixel (display, DefaultScreen (display));
>
>  gc_values.foreground = white;
>  gc_values.background = white;
>  white_gc = XCreateGC (display, win,
>                        GCForeground | GCBackground, &gc_values);
>  gc_values.foreground = black;
>  gc_values.background = black;
>  black_gc = XCreateGC (display, win,
>                        GCForeground | GCBackground, &gc_values);
>
>  XFillRectangle (display, win, white_gc, 0, 0, PIXMAP_WIDTH, PIXMAP_HEIGHT);
>  XDrawArc (display, win, black_gc, PIXMAP_WIDTH / 4, PIXMAP_HEIGHT / 4,
>            PIXMAP_WIDTH / 2, PIXMAP_HEIGHT / 2, 0, 360 * 64);
>
>  XFreeGC (display, white_gc);
>  XFreeGC (display, black_gc);
>}
>
>static void
>event_loop (Data *data)
>{
>  while (1)
>    {
>      XEvent event;
>      XNextEvent (data->dpy, &event);
>
>      if (event.type == KeyPress)
>        {
>          KeySym sym = XKeycodeToKeysym (data->dpy, event.xkey.keycode, 0);
>
>          if (sym == XK_Escape || sym == XK_q || sym == XK_Q)
>            break;
>        }
>      else if (event.type == MapNotify)
>        {
>          if (event.xany.window == data->sub_win && data->win_pixmap == None)
>            {
>              data->win_pixmap = composite_window (data->dpy, data->sub_win);
>              data->glx_pixmap = create_glx_pixmap (data->dpy, data->win_pixmap);
>              draw_to_window (data->dpy, data->sub_win);
>              XClearArea (data->dpy, data->w, 0, 0, 0, 0, True);
>            }
>        }
>      else if (event.type == Expose)
>        redraw (data);
>    }
>}
>
>static Window
>create_x_window (Display *display)
>{
>  Window win;
>  unsigned long white;
>
>  white = WhitePixel (display, DefaultScreen (display));
>
>  win = XCreateSimpleWindow (display, DefaultRootWindow (display),
>                             0, 0, PIXMAP_WIDTH, PIXMAP_HEIGHT,
>                             0, white, white);
>  XSelectInput (display, win, StructureNotifyMask);
>
>  return win;
>}
>
>int
>main (int argc, char *argv[])
>{
>  Data data;
>
>  data.win_pixmap = None;
>  data.glx_pixmap = None;
>
>  data.dpy = XOpenDisplay (NULL);
>
>  if (!data.dpy)
>    {
>      printf ("Error: XOpenDisplay failed\n");
>      return 1;
>    }
>
>  data.w = make_window (&data, 640, 480);
>
>  data.sub_win = create_x_window (data.dpy);
>  XMapWindow (data.dpy, data.sub_win);
>
>  data.bind_tex_image
>    = (BindTexImageFunc) glXGetProcAddress ((GLubyte *) "glXBindTexImageEXT");
>  data.release_tex_image
>    = (ReleaseTexImageFunc) glXGetProcAddress ((GLubyte *)
>                                               "glXReleaseTexImageEXT");
>
>  if (data.bind_tex_image == NULL || data.release_tex_image == NULL)
>    {
>      fprintf (stderr, "Missing TFP extension\n");
>      return 1;
>    }
>
>  /* init GL state */
>  glClearColor (0.0, 0.0, 1.0, 1.0);
>
>  XMapWindow (data.dpy, data.w);
>
>  event_loop (&data);
>
>  glXMakeCurrent (data.dpy, None, NULL);
>  glXDestroyContext (data.dpy, data.ctx);
>  XDestroyWindow (data.dpy, data.w);
>
>  if (data.glx_pixmap != None)
>    glXDestroyGLXPixmap (data.dpy, data.glx_pixmap);
>  if (data.win_pixmap != None)
>    uncomposite_window (data.dpy, data.sub_win, data.win_pixmap);
>  XDestroyWindow (data.dpy, data.sub_win);
>
>  XCloseDisplay (data.dpy);
>
>  return 0;
>}

Actions: View

Attachments on bug 19910: 22487 | 22488

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.