|
|
@@ -0,0 +1,14774 @@
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/corender.c Mesa-7.8.1.patched/progs/xdemos/corender.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/corender.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/corender.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,400 @@
|
|
|
++/**
|
|
|
++ * Example of cooperative rendering into one window by two processes.
|
|
|
++ * The first instance of the program creates the GLX window.
|
|
|
++ * The second instance of the program gets the window ID from the first
|
|
|
++ * and draws into it.
|
|
|
++ * Socket IPC is used for synchronization.
|
|
|
++ *
|
|
|
++ * Usage:
|
|
|
++ * 1. run 'corender &'
|
|
|
++ * 2. run 'corender 2' (any arg will do)
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * 11 Oct 2007
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <assert.h>
|
|
|
++#include <math.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include "ipc.h"
|
|
|
++
|
|
|
++
|
|
|
++#ifndef M_PI
|
|
|
++#define M_PI 3.14159265358979323846
|
|
|
++#endif
|
|
|
++
|
|
|
++static int MyID = 0; /* 0 or 1 */
|
|
|
++static int WindowID = 0;
|
|
|
++static GLXContext Context = 0;
|
|
|
++static int Width = 700, Height = 350;
|
|
|
++static int Rot = 0;
|
|
|
++static int Sock = 0;
|
|
|
++
|
|
|
++static GLfloat Red[4] = {1.0, 0.2, 0.2, 1.0};
|
|
|
++static GLfloat Blue[4] = {0.2, 0.2, 1.0, 1.0};
|
|
|
++
|
|
|
++static int Sync = 1; /** synchronized rendering? */
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++setup_ipc(void)
|
|
|
++{
|
|
|
++ int k, port = 10001;
|
|
|
++
|
|
|
++ if (MyID == 0) {
|
|
|
++ /* I'm the first one, wait for connection from second */
|
|
|
++ k = CreatePort(&port);
|
|
|
++ assert(k != -1);
|
|
|
++
|
|
|
++ printf("Waiting for connection from another 'corender'\n");
|
|
|
++ Sock = AcceptConnection(k);
|
|
|
++ assert(Sock != -1);
|
|
|
++
|
|
|
++ printf("Got connection, sending windowID\n");
|
|
|
++
|
|
|
++ /* send windowID */
|
|
|
++ SendData(Sock, &WindowID, sizeof(WindowID));
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* I'm the second one, connect to first */
|
|
|
++ char hostname[1000];
|
|
|
++
|
|
|
++ MyHostName(hostname, 1000);
|
|
|
++ Sock = Connect(hostname, port);
|
|
|
++ assert(Sock != -1);
|
|
|
++
|
|
|
++ /* get windowID */
|
|
|
++ ReceiveData(Sock, &WindowID, sizeof(WindowID));
|
|
|
++ printf("Contacted first 'corender', getting WindowID\n");
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/** from GLUT */
|
|
|
++static void
|
|
|
++doughnut(GLfloat r, GLfloat R, GLint nsides, GLint rings)
|
|
|
++{
|
|
|
++ int i, j;
|
|
|
++ GLfloat theta, phi, theta1;
|
|
|
++ GLfloat cosTheta, sinTheta;
|
|
|
++ GLfloat cosTheta1, sinTheta1;
|
|
|
++ GLfloat ringDelta, sideDelta;
|
|
|
++
|
|
|
++ ringDelta = 2.0 * M_PI / rings;
|
|
|
++ sideDelta = 2.0 * M_PI / nsides;
|
|
|
++
|
|
|
++ theta = 0.0;
|
|
|
++ cosTheta = 1.0;
|
|
|
++ sinTheta = 0.0;
|
|
|
++ for (i = rings - 1; i >= 0; i--) {
|
|
|
++ theta1 = theta + ringDelta;
|
|
|
++ cosTheta1 = cos(theta1);
|
|
|
++ sinTheta1 = sin(theta1);
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ phi = 0.0;
|
|
|
++ for (j = nsides; j >= 0; j--) {
|
|
|
++ GLfloat cosPhi, sinPhi, dist;
|
|
|
++
|
|
|
++ phi += sideDelta;
|
|
|
++ cosPhi = cos(phi);
|
|
|
++ sinPhi = sin(phi);
|
|
|
++ dist = R + r * cosPhi;
|
|
|
++
|
|
|
++ glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
|
|
|
++ glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi);
|
|
|
++ glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi);
|
|
|
++ glVertex3f(cosTheta * dist, -sinTheta * dist, r * sinPhi);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++ theta = theta1;
|
|
|
++ cosTheta = cosTheta1;
|
|
|
++ sinTheta = sinTheta1;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++redraw(Display *dpy)
|
|
|
++{
|
|
|
++ int dbg = 0;
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, WindowID, Context);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++ glClearColor(0.5, 0.5, 0.5, 0.0);
|
|
|
++
|
|
|
++ if (MyID == 0) {
|
|
|
++ /* First process */
|
|
|
++
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-1, 0, 0);
|
|
|
++ glRotatef(Rot, 1, 0, 0);
|
|
|
++ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Red);
|
|
|
++ doughnut(0.5, 2.0, 20, 30);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glFinish();
|
|
|
++ if (!Sync) {
|
|
|
++ usleep(1000*10);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* signal second process to render */
|
|
|
++ if (Sync) {
|
|
|
++ int code = 1;
|
|
|
++ if (dbg) printf("0: send signal\n");
|
|
|
++ SendData(Sock, &code, sizeof(code));
|
|
|
++ SendData(Sock, &Rot, sizeof(Rot));
|
|
|
++ }
|
|
|
++
|
|
|
++ /* wait for second process to finish rendering */
|
|
|
++ if (Sync) {
|
|
|
++ int code = 0;
|
|
|
++ if (dbg) printf("0: wait signal\n");
|
|
|
++ ReceiveData(Sock, &code, sizeof(code));
|
|
|
++ if (dbg) printf("0: got signal\n");
|
|
|
++ assert(code == 2);
|
|
|
++ }
|
|
|
++
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* Second process */
|
|
|
++
|
|
|
++ /* wait for first process's signal for me to render */
|
|
|
++ if (Sync) {
|
|
|
++ int code = 0;
|
|
|
++ if (dbg) printf("1: wait signal\n");
|
|
|
++ ReceiveData(Sock, &code, sizeof(code));
|
|
|
++ ReceiveData(Sock, &Rot, sizeof(Rot));
|
|
|
++
|
|
|
++ if (dbg) printf("1: got signal\n");
|
|
|
++ assert(code == 1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* XXX this clear should not be here, but for some reason, it
|
|
|
++ * makes things _mostly_ work correctly w/ NVIDIA's driver.
|
|
|
++ * There's only occasional glitches.
|
|
|
++ * Without this glClear(), depth buffer for the second process
|
|
|
++ * is pretty much broken.
|
|
|
++ */
|
|
|
++ /* glClear(GL_DEPTH_BUFFER_BIT); */
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(1, 0, 0);
|
|
|
++ glRotatef(Rot + 90 , 1, 0, 0);
|
|
|
++ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Blue);
|
|
|
++ doughnut(0.5, 2.0, 20, 30);
|
|
|
++ glPopMatrix();
|
|
|
++ glFinish();
|
|
|
++
|
|
|
++ glXSwapBuffers(dpy, WindowID);
|
|
|
++ usleep(1000*10);
|
|
|
++
|
|
|
++ /* signal first process that I'm done rendering */
|
|
|
++ if (Sync) {
|
|
|
++ int code = 2;
|
|
|
++ if (dbg) printf("1: send signal\n");
|
|
|
++ SendData(Sock, &code, sizeof(code));
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++resize(Display *dpy, int width, int height)
|
|
|
++{
|
|
|
++ float ar = (float) width / height;
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, WindowID, Context);
|
|
|
++
|
|
|
++ glViewport(0, 0, width, height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-ar, ar, 1.0, -1.0, 5.0, 200.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0, 0, -15);
|
|
|
++
|
|
|
++ Width = width;
|
|
|
++ Height = height;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++set_window_title(Display *dpy, Window win, const char *title)
|
|
|
++{
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.flags = 0;
|
|
|
++ XSetStandardProperties(dpy, win, title, title,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static Window
|
|
|
++make_gl_window(Display *dpy, XVisualInfo *visinfo, int width, int height)
|
|
|
++{
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ int x = 0, y = 0;
|
|
|
++ char *name = NULL;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, x, y, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++set_event_mask(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ XChangeWindowAttributes(dpy, win, CWEventMask, &attr);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ while (XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ redraw(dpy);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ resize(dpy, event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ default:
|
|
|
++ /* nothing */
|
|
|
++ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if (MyID == 0 || !Sync)
|
|
|
++ Rot += 1;
|
|
|
++ redraw(dpy);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static XVisualInfo *
|
|
|
++choose_visual(Display *dpy)
|
|
|
++{
|
|
|
++ int attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int scrnum = DefaultScreen( dpy );
|
|
|
++ return glXChooseVisual(dpy, scrnum, attribs);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++parse_opts(int argc, char *argv[])
|
|
|
++{
|
|
|
++ if (argc > 1) {
|
|
|
++ MyID = 1;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main( int argc, char *argv[] )
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ parse_opts(argc, argv);
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++
|
|
|
++ visinfo = choose_visual(dpy);
|
|
|
++
|
|
|
++ Context = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!Context) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (MyID == 0) {
|
|
|
++ WindowID = make_gl_window(dpy, visinfo, Width, Height);
|
|
|
++ set_window_title(dpy, WindowID, "corender");
|
|
|
++ XMapWindow(dpy, WindowID);
|
|
|
++ /*printf("WindowID 0x%x\n", (int) WindowID);*/
|
|
|
++ }
|
|
|
++
|
|
|
++ /* do ipc hand-shake here */
|
|
|
++ setup_ipc();
|
|
|
++ assert(Sock);
|
|
|
++ assert(WindowID);
|
|
|
++
|
|
|
++ if (MyID == 1) {
|
|
|
++ set_event_mask(dpy, WindowID);
|
|
|
++ }
|
|
|
++
|
|
|
++ resize(dpy, Width, Height);
|
|
|
++
|
|
|
++ event_loop(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glsync.c Mesa-7.8.1.patched/progs/xdemos/glsync.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glsync.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glsync.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,295 @@
|
|
|
++/*
|
|
|
++ * Copyright © 2007 Intel Corporation
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice (including the next
|
|
|
++ * paragraph) shall be included in all copies or substantial portions of the
|
|
|
++ * Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
++ * IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ * Authors:
|
|
|
++ * Jesse Barnes <jesse.barnes@intel.com>
|
|
|
++ *
|
|
|
++ */
|
|
|
++
|
|
|
++/** @file glsync.c
|
|
|
++ * The program is simple: it paints a window alternating colors (red &
|
|
|
++ * white) either as fast as possible or synchronized to vblank events
|
|
|
++ *
|
|
|
++ * If run normally, the program should display a window that exhibits
|
|
|
++ * significant tearing between red and white colors (e.g. you might get
|
|
|
++ * a "waterfall" effect of red and white horizontal bars).
|
|
|
++ *
|
|
|
++ * If run with the '-s b' option, the program should synchronize the
|
|
|
++ * window color changes with the vertical blank period, resulting in a
|
|
|
++ * window that looks orangish with a high frequency flicker (which may
|
|
|
++ * be invisible). If the window is moved to another screen, this
|
|
|
++ * property should be preserved. If the window spans two screens, it
|
|
|
++ * shouldn't tear on whichever screen most of the window is on; the
|
|
|
++ * portion on the other screen may show some tearing (like the
|
|
|
++ * waterfall effect above).
|
|
|
++ *
|
|
|
++ * Other options include '-w <width>' and '-h <height' to set the
|
|
|
++ * window size.
|
|
|
++ */
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glu.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <GL/glxext.h>
|
|
|
++#include <X11/X.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/Xutil.h>
|
|
|
++
|
|
|
++void (*video_sync_get)();
|
|
|
++void (*video_sync)();
|
|
|
++void (*swap_interval)();
|
|
|
++
|
|
|
++static int GLXExtensionSupported(Display *dpy, const char *extension)
|
|
|
++{
|
|
|
++ const char *extensionsString, *pos;
|
|
|
++
|
|
|
++ extensionsString = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
|
|
|
++
|
|
|
++ pos = strstr(extensionsString, extension);
|
|
|
++
|
|
|
++ if (pos != NULL && (pos == extensionsString || pos[-1] == ' ') &&
|
|
|
++ (pos[strlen(extension)] == ' ' || pos[strlen(extension)] == '\0'))
|
|
|
++ return 1;
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++extern char *optarg;
|
|
|
++extern int optind, opterr, optopt;
|
|
|
++static char optstr[] = "w:h:s:vi:";
|
|
|
++
|
|
|
++enum sync_type {
|
|
|
++ none = 0,
|
|
|
++ sgi_video_sync,
|
|
|
++ buffer_swap
|
|
|
++};
|
|
|
++
|
|
|
++static void usage(char *name)
|
|
|
++{
|
|
|
++ printf("usage: %s [-w <width>] [-h <height>] [-s<sync method>] "
|
|
|
++ "[-v]\n", name);
|
|
|
++ printf("\t-s<sync method>:\n");
|
|
|
++ printf("\t\tn: none\n");
|
|
|
++ printf("\t\ts: SGI video sync extension\n");
|
|
|
++ printf("\t\tb: buffer swap\n");
|
|
|
++ printf("\t-i<swap interval>\n");
|
|
|
++ printf("\t-v: verbose (print count)\n");
|
|
|
++ exit(-1);
|
|
|
++}
|
|
|
++
|
|
|
++int main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *disp;
|
|
|
++ XVisualInfo *pvi;
|
|
|
++ XSetWindowAttributes swa;
|
|
|
++ GLint last_val = -1, count = 0;
|
|
|
++ Window winGL;
|
|
|
++ GLXContext context;
|
|
|
++ int dummy;
|
|
|
++ Atom wmDelete;
|
|
|
++ enum sync_type waitforsync = none;
|
|
|
++ int width = 500, height = 500, verbose = 0, interval = 1;
|
|
|
++ int c, i = 1;
|
|
|
++ int ret;
|
|
|
++ int attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int db_attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ XSizeHints sizehints;
|
|
|
++
|
|
|
++ opterr = 0;
|
|
|
++ while ((c = getopt(argc, argv, optstr)) != -1) {
|
|
|
++ switch (c) {
|
|
|
++ case 'w':
|
|
|
++ width = atoi(optarg);
|
|
|
++ break;
|
|
|
++ case 'h':
|
|
|
++ height = atoi(optarg);
|
|
|
++ break;
|
|
|
++ case 's':
|
|
|
++ switch (optarg[0]) {
|
|
|
++ case 'n':
|
|
|
++ waitforsync = none;
|
|
|
++ break;
|
|
|
++ case 's':
|
|
|
++ waitforsync = sgi_video_sync;
|
|
|
++ break;
|
|
|
++ case 'b':
|
|
|
++ waitforsync = buffer_swap;
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ usage(argv[0]);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ case 'v':
|
|
|
++ verbose = 1;
|
|
|
++ break;
|
|
|
++ case 'i':
|
|
|
++ interval = atoi(optarg);
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ usage(argv[0]);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ disp = XOpenDisplay(NULL);
|
|
|
++ if (!disp) {
|
|
|
++ fprintf(stderr, "failed to open display\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!glXQueryExtension(disp, &dummy, &dummy)) {
|
|
|
++ fprintf(stderr, "glXQueryExtension failed\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!GLXExtensionSupported(disp, "GLX_SGI_video_sync")) {
|
|
|
++ fprintf(stderr, "GLX_SGI_video_sync not supported, exiting\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (waitforsync != buffer_swap) {
|
|
|
++ pvi = glXChooseVisual(disp, DefaultScreen(disp), attribs);
|
|
|
++ } else {
|
|
|
++ pvi = glXChooseVisual(disp, DefaultScreen(disp), db_attribs);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!pvi) {
|
|
|
++ fprintf(stderr, "failed to choose visual, exiting\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ pvi->screen = DefaultScreen(disp);
|
|
|
++
|
|
|
++ swa.colormap = XCreateColormap(disp, RootWindow(disp, pvi->screen),
|
|
|
++ pvi->visual, AllocNone);
|
|
|
++ swa.border_pixel = 0;
|
|
|
++ swa.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
|
|
|
++ StructureNotifyMask;
|
|
|
++ winGL = XCreateWindow(disp, RootWindow(disp, pvi->screen),
|
|
|
++ 0, 0,
|
|
|
++ width, height,
|
|
|
++ 0, pvi->depth, InputOutput, pvi->visual,
|
|
|
++ CWBorderPixel | CWColormap | CWEventMask, &swa);
|
|
|
++ if (!winGL) {
|
|
|
++ fprintf(stderr, "window creation failed\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++ wmDelete = XInternAtom(disp, "WM_DELETE_WINDOW", True);
|
|
|
++ XSetWMProtocols(disp, winGL, &wmDelete, 1);
|
|
|
++
|
|
|
++ sizehints.x = 0;
|
|
|
++ sizehints.y = 0;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++
|
|
|
++ XSetNormalHints(disp, winGL, &sizehints);
|
|
|
++ XSetStandardProperties(disp, winGL, "glsync test", "glsync text",
|
|
|
++ None, NULL, 0, &sizehints);
|
|
|
++
|
|
|
++ context = glXCreateContext(disp, pvi, NULL, GL_TRUE);
|
|
|
++ if (!context) {
|
|
|
++ fprintf(stderr, "failed to create glx context\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ XMapWindow(disp, winGL);
|
|
|
++ ret = glXMakeCurrent(disp, winGL, context);
|
|
|
++ if (!ret) {
|
|
|
++ fprintf(stderr, "failed to make context current: %d\n", ret);
|
|
|
++ }
|
|
|
++
|
|
|
++ video_sync_get = glXGetProcAddress((unsigned char *)"glXGetVideoSyncSGI");
|
|
|
++ video_sync = glXGetProcAddress((unsigned char *)"glXWaitVideoSyncSGI");
|
|
|
++
|
|
|
++ swap_interval = glXGetProcAddress((unsigned char *)"glXSwapIntervalSGI");
|
|
|
++
|
|
|
++ if (!video_sync_get || !video_sync || !swap_interval) {
|
|
|
++ fprintf(stderr, "failed to get sync functions\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (waitforsync == buffer_swap) {
|
|
|
++ swap_interval(interval);
|
|
|
++ fprintf(stderr, "set swap interval to %d\n", interval);
|
|
|
++ }
|
|
|
++ video_sync_get(&count);
|
|
|
++ count++;
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++ while (i++) {
|
|
|
++ /* Alternate colors to make tearing obvious */
|
|
|
++ if (i & 1) {
|
|
|
++ glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
++ glColor3f(1.0f, 1.0f, 1.0f);
|
|
|
++ } else {
|
|
|
++ glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
|
|
|
++ glColor3f(1.0f, 0.0f, 0.0f);
|
|
|
++ }
|
|
|
++
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++ glRectf(0, 0, width, height);
|
|
|
++
|
|
|
++ /* Wait for vsync */
|
|
|
++ if (waitforsync == sgi_video_sync) {
|
|
|
++ if (verbose)
|
|
|
++ fprintf(stderr, "waiting on count %d\n", count);
|
|
|
++ video_sync(2, (count + 1) % 2, &count);
|
|
|
++ if (count < last_val)
|
|
|
++ fprintf(stderr, "error: vblank count went backwards: %d -> %d\n", last_val, count);
|
|
|
++ if (count == last_val)
|
|
|
++ fprintf(stderr, "error: count didn't change: %d\n", count);
|
|
|
++ last_val = count;
|
|
|
++ glFlush();
|
|
|
++ } else if (waitforsync == buffer_swap) {
|
|
|
++ glXSwapBuffers(disp, winGL);
|
|
|
++ } else {
|
|
|
++ video_sync_get(&count);
|
|
|
++ sleep(1);
|
|
|
++ glFinish();
|
|
|
++ }
|
|
|
++
|
|
|
++ if (verbose) {
|
|
|
++ video_sync_get(&count);
|
|
|
++ fprintf(stderr, "current count: %d\n", count);
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ XDestroyWindow(disp, winGL);
|
|
|
++ glXDestroyContext(disp, context);
|
|
|
++ XCloseDisplay(disp);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glthreads.c Mesa-7.8.1.patched/progs/xdemos/glthreads.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glthreads.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glthreads.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,716 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 2000 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * This program tests GLX thread safety.
|
|
|
++ * Command line options:
|
|
|
++ * -p Open a display connection for each thread
|
|
|
++ * -l Enable application-side locking
|
|
|
++ * -n <num threads> Number of threads to create (default is 2)
|
|
|
++ * -display <display name> Specify X display (default is $DISPLAY)
|
|
|
++ * -t Use texture mapping
|
|
|
++ *
|
|
|
++ * Brian Paul 20 July 2000
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Notes:
|
|
|
++ * - Each thread gets its own GLX context.
|
|
|
++ *
|
|
|
++ * - The GLX contexts share texture objects.
|
|
|
++ *
|
|
|
++ * - When 't' is pressed to update the texture image, the window/thread which
|
|
|
++ * has input focus is signalled to change the texture. The other threads
|
|
|
++ * should see the updated texture the next time they call glBindTexture.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#if defined(PTHREADS) /* defined by Mesa on Linux and other platforms */
|
|
|
++
|
|
|
++#include <assert.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <math.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <pthread.h>
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Each window/thread/context:
|
|
|
++ */
|
|
|
++struct winthread {
|
|
|
++ Display *Dpy;
|
|
|
++ int Index;
|
|
|
++ pthread_t Thread;
|
|
|
++ Window Win;
|
|
|
++ GLXContext Context;
|
|
|
++ float Angle;
|
|
|
++ int WinWidth, WinHeight;
|
|
|
++ GLboolean NewSize;
|
|
|
++ GLboolean Initialized;
|
|
|
++ GLboolean MakeNewTexture;
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++#define MAX_WINTHREADS 100
|
|
|
++static struct winthread WinThreads[MAX_WINTHREADS];
|
|
|
++static int NumWinThreads = 0;
|
|
|
++static volatile GLboolean ExitFlag = GL_FALSE;
|
|
|
++
|
|
|
++static GLboolean MultiDisplays = 0;
|
|
|
++static GLboolean Locking = 0;
|
|
|
++static GLboolean Texture = GL_FALSE;
|
|
|
++static GLuint TexObj = 12;
|
|
|
++static GLboolean Animate = GL_TRUE;
|
|
|
++
|
|
|
++static pthread_mutex_t Mutex;
|
|
|
++static pthread_cond_t CondVar;
|
|
|
++static pthread_mutex_t CondMutex;
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Error(const char *msg)
|
|
|
++{
|
|
|
++ fprintf(stderr, "Error: %s\n", msg);
|
|
|
++ exit(1);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++signal_redraw(void)
|
|
|
++{
|
|
|
++ pthread_mutex_lock(&CondMutex);
|
|
|
++ pthread_cond_broadcast(&CondVar);
|
|
|
++ pthread_mutex_unlock(&CondMutex);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++MakeNewTexture(struct winthread *wt)
|
|
|
++{
|
|
|
++#define TEX_SIZE 128
|
|
|
++ static float step = 0.0;
|
|
|
++ GLfloat image[TEX_SIZE][TEX_SIZE][4];
|
|
|
++ GLint width;
|
|
|
++ int i, j;
|
|
|
++
|
|
|
++ for (j = 0; j < TEX_SIZE; j++) {
|
|
|
++ for (i = 0; i < TEX_SIZE; i++) {
|
|
|
++ float dt = 5.0 * (j - 0.5 * TEX_SIZE) / TEX_SIZE;
|
|
|
++ float ds = 5.0 * (i - 0.5 * TEX_SIZE) / TEX_SIZE;
|
|
|
++ float r = dt * dt + ds * ds + step;
|
|
|
++ image[j][i][0] =
|
|
|
++ image[j][i][1] =
|
|
|
++ image[j][i][2] = 0.75 + 0.25 * cos(r);
|
|
|
++ image[j][i][3] = 1.0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ step += 0.5;
|
|
|
++
|
|
|
++ glBindTexture(GL_TEXTURE_2D, TexObj);
|
|
|
++
|
|
|
++ glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
|
|
|
++ if (width) {
|
|
|
++ assert(width == TEX_SIZE);
|
|
|
++ /* sub-tex replace */
|
|
|
++ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, TEX_SIZE, TEX_SIZE,
|
|
|
++ GL_RGBA, GL_FLOAT, image);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* create new */
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
++
|
|
|
++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0,
|
|
|
++ GL_RGBA, GL_FLOAT, image);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/* draw a colored cube */
|
|
|
++static void
|
|
|
++draw_object(void)
|
|
|
++{
|
|
|
++ glPushMatrix();
|
|
|
++ glScalef(0.75, 0.75, 0.75);
|
|
|
++
|
|
|
++ glColor3f(1, 0, 0);
|
|
|
++
|
|
|
++ if (Texture) {
|
|
|
++ glBindTexture(GL_TEXTURE_2D, TexObj);
|
|
|
++ glEnable(GL_TEXTURE_2D);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glDisable(GL_TEXTURE_2D);
|
|
|
++ }
|
|
|
++
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++
|
|
|
++ /* -X */
|
|
|
++ glColor3f(0, 1, 1);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f(-1, 1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f(-1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, -1, 1);
|
|
|
++
|
|
|
++ /* +X */
|
|
|
++ glColor3f(1, 0, 0);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f(1, 1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f(1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(1, -1, 1);
|
|
|
++
|
|
|
++ /* -Y */
|
|
|
++ glColor3f(1, 0, 1);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, -1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, -1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, -1, 1);
|
|
|
++
|
|
|
++ /* +Y */
|
|
|
++ glColor3f(0, 1, 0);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, 1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, 1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, 1, 1);
|
|
|
++
|
|
|
++ /* -Z */
|
|
|
++ glColor3f(1, 1, 0);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, -1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, 1, -1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, 1, -1);
|
|
|
++
|
|
|
++ /* +Y */
|
|
|
++ glColor3f(0, 0, 1);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, 1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, -1, 1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, 1, 1);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* signal resize of given window */
|
|
|
++static void
|
|
|
++resize(struct winthread *wt, int w, int h)
|
|
|
++{
|
|
|
++ wt->NewSize = GL_TRUE;
|
|
|
++ wt->WinWidth = w;
|
|
|
++ wt->WinHeight = h;
|
|
|
++ if (!Animate)
|
|
|
++ signal_redraw();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * We have an instance of this for each thread.
|
|
|
++ */
|
|
|
++static void
|
|
|
++draw_loop(struct winthread *wt)
|
|
|
++{
|
|
|
++ while (!ExitFlag) {
|
|
|
++
|
|
|
++ if (Locking)
|
|
|
++ pthread_mutex_lock(&Mutex);
|
|
|
++
|
|
|
++ glXMakeCurrent(wt->Dpy, wt->Win, wt->Context);
|
|
|
++ if (!wt->Initialized) {
|
|
|
++ printf("glthreads: %d: GL_RENDERER = %s\n", wt->Index,
|
|
|
++ (char *) glGetString(GL_RENDERER));
|
|
|
++ if (Texture /*&& wt->Index == 0*/) {
|
|
|
++ MakeNewTexture(wt);
|
|
|
++ }
|
|
|
++ wt->Initialized = GL_TRUE;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (Locking)
|
|
|
++ pthread_mutex_unlock(&Mutex);
|
|
|
++
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ if (wt->NewSize) {
|
|
|
++ GLfloat w = (float) wt->WinWidth / (float) wt->WinHeight;
|
|
|
++ glViewport(0, 0, wt->WinWidth, wt->WinHeight);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-w, w, -1.0, 1.0, 1.5, 10);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0, 0, -2.5);
|
|
|
++ wt->NewSize = GL_FALSE;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (wt->MakeNewTexture) {
|
|
|
++ MakeNewTexture(wt);
|
|
|
++ wt->MakeNewTexture = GL_FALSE;
|
|
|
++ }
|
|
|
++
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(wt->Angle, 0, 1, 0);
|
|
|
++ glRotatef(wt->Angle, 1, 0, 0);
|
|
|
++ glScalef(0.7, 0.7, 0.7);
|
|
|
++ draw_object();
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ if (Locking)
|
|
|
++ pthread_mutex_lock(&Mutex);
|
|
|
++
|
|
|
++ glXSwapBuffers(wt->Dpy, wt->Win);
|
|
|
++
|
|
|
++ if (Locking)
|
|
|
++ pthread_mutex_unlock(&Mutex);
|
|
|
++
|
|
|
++ if (Animate) {
|
|
|
++ usleep(5000);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* wait for signal to draw */
|
|
|
++ pthread_mutex_lock(&CondMutex);
|
|
|
++ pthread_cond_wait(&CondVar, &CondMutex);
|
|
|
++ pthread_mutex_unlock(&CondMutex);
|
|
|
++ }
|
|
|
++ wt->Angle += 1.0;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++keypress(XEvent *event, struct winthread *wt)
|
|
|
++{
|
|
|
++ char buf[100];
|
|
|
++ KeySym keySym;
|
|
|
++ XComposeStatus stat;
|
|
|
++
|
|
|
++ XLookupString(&event->xkey, buf, sizeof(buf), &keySym, &stat);
|
|
|
++
|
|
|
++ switch (keySym) {
|
|
|
++ case XK_Escape:
|
|
|
++ /* tell all threads to exit */
|
|
|
++ if (!Animate) {
|
|
|
++ signal_redraw();
|
|
|
++ }
|
|
|
++ ExitFlag = GL_TRUE;
|
|
|
++ /*printf("exit draw_loop %d\n", wt->Index);*/
|
|
|
++ return;
|
|
|
++ case XK_t:
|
|
|
++ case XK_T:
|
|
|
++ if (Texture) {
|
|
|
++ wt->MakeNewTexture = GL_TRUE;
|
|
|
++ if (!Animate)
|
|
|
++ signal_redraw();
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ case XK_a:
|
|
|
++ case XK_A:
|
|
|
++ Animate = !Animate;
|
|
|
++ if (Animate) /* yes, prev Animate state! */
|
|
|
++ signal_redraw();
|
|
|
++ break;
|
|
|
++ case XK_s:
|
|
|
++ case XK_S:
|
|
|
++ if (!Animate)
|
|
|
++ signal_redraw();
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ ; /* nop */
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * The main process thread runs this loop.
|
|
|
++ * Single display connection for all threads.
|
|
|
++ */
|
|
|
++static void
|
|
|
++event_loop(Display *dpy)
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ assert(!MultiDisplays);
|
|
|
++
|
|
|
++ while (!ExitFlag) {
|
|
|
++
|
|
|
++ if (Locking) {
|
|
|
++ while (1) {
|
|
|
++ int k;
|
|
|
++ pthread_mutex_lock(&Mutex);
|
|
|
++ k = XPending(dpy);
|
|
|
++ if (k) {
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ pthread_mutex_unlock(&Mutex);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ pthread_mutex_unlock(&Mutex);
|
|
|
++ usleep(5000);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ }
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case ConfigureNotify:
|
|
|
++ /* Find winthread for this event's window */
|
|
|
++ for (i = 0; i < NumWinThreads; i++) {
|
|
|
++ struct winthread *wt = &WinThreads[i];
|
|
|
++ if (event.xconfigure.window == wt->Win) {
|
|
|
++ resize(wt, event.xconfigure.width,
|
|
|
++ event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ for (i = 0; i < NumWinThreads; i++) {
|
|
|
++ struct winthread *wt = &WinThreads[i];
|
|
|
++ if (event.xkey.window == wt->Win) {
|
|
|
++ keypress(&event, wt);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ /*no-op*/ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Separate display connection for each thread.
|
|
|
++ */
|
|
|
++static void
|
|
|
++event_loop_multi(void)
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++ int w = 0;
|
|
|
++
|
|
|
++ assert(MultiDisplays);
|
|
|
++
|
|
|
++ while (!ExitFlag) {
|
|
|
++ struct winthread *wt = &WinThreads[w];
|
|
|
++ if (XPending(wt->Dpy)) {
|
|
|
++ XNextEvent(wt->Dpy, &event);
|
|
|
++ switch (event.type) {
|
|
|
++ case ConfigureNotify:
|
|
|
++ resize(wt, event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ keypress(&event, wt);
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ ; /* nop */
|
|
|
++ }
|
|
|
++ }
|
|
|
++ w = (w + 1) % NumWinThreads;
|
|
|
++ usleep(5000);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * we'll call this once for each thread, before the threads are created.
|
|
|
++ */
|
|
|
++static void
|
|
|
++create_window(struct winthread *wt, GLXContext shareCtx)
|
|
|
++{
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int width = 160, height = 160;
|
|
|
++ int xpos = (wt->Index % 8) * (width + 10);
|
|
|
++ int ypos = (wt->Index / 8) * (width + 20);
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(wt->Dpy);
|
|
|
++ root = RootWindow(wt->Dpy, scrnum);
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(wt->Dpy, scrnum, attrib);
|
|
|
++ if (!visinfo) {
|
|
|
++ Error("Unable to find RGB, Z, double-buffered visual");
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(wt->Dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow(wt->Dpy, root, xpos, ypos, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++ if (!win) {
|
|
|
++ Error("Couldn't create window");
|
|
|
++ }
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(wt->Dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(wt->Dpy, win, "glthreads", "glthreads",
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ ctx = glXCreateContext(wt->Dpy, visinfo, shareCtx, True);
|
|
|
++ if (!ctx) {
|
|
|
++ Error("Couldn't create GLX context");
|
|
|
++ }
|
|
|
++
|
|
|
++ XMapWindow(wt->Dpy, win);
|
|
|
++ XSync(wt->Dpy, 0);
|
|
|
++
|
|
|
++ /* save the info for this window/context */
|
|
|
++ wt->Win = win;
|
|
|
++ wt->Context = ctx;
|
|
|
++ wt->Angle = 0.0;
|
|
|
++ wt->WinWidth = width;
|
|
|
++ wt->WinHeight = height;
|
|
|
++ wt->NewSize = GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Called by pthread_create()
|
|
|
++ */
|
|
|
++static void *
|
|
|
++thread_function(void *p)
|
|
|
++{
|
|
|
++ struct winthread *wt = (struct winthread *) p;
|
|
|
++ draw_loop(wt);
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * called before exit to wait for all threads to finish
|
|
|
++ */
|
|
|
++static void
|
|
|
++clean_up(void)
|
|
|
++{
|
|
|
++ int i;
|
|
|
++
|
|
|
++ /* wait for threads to finish */
|
|
|
++ for (i = 0; i < NumWinThreads; i++) {
|
|
|
++ pthread_join(WinThreads[i].Thread, NULL);
|
|
|
++ }
|
|
|
++
|
|
|
++ for (i = 0; i < NumWinThreads; i++) {
|
|
|
++ glXDestroyContext(WinThreads[i].Dpy, WinThreads[i].Context);
|
|
|
++ XDestroyWindow(WinThreads[i].Dpy, WinThreads[i].Win);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++usage(void)
|
|
|
++{
|
|
|
++ printf("glthreads: test of GL thread safety (any key = exit)\n");
|
|
|
++ printf("Usage:\n");
|
|
|
++ printf(" glthreads [options]\n");
|
|
|
++ printf("Options:\n");
|
|
|
++ printf(" -display DISPLAYNAME Specify display string\n");
|
|
|
++ printf(" -n NUMTHREADS Number of threads to create\n");
|
|
|
++ printf(" -p Use a separate display connection for each thread\n");
|
|
|
++ printf(" -l Use application-side locking\n");
|
|
|
++ printf(" -t Enable texturing\n");
|
|
|
++ printf("Keyboard:\n");
|
|
|
++ printf(" Esc Exit\n");
|
|
|
++ printf(" t Change texture image (requires -t option)\n");
|
|
|
++ printf(" a Toggle animation\n");
|
|
|
++ printf(" s Step rotation (when not animating)\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ char *displayName = NULL;
|
|
|
++ int numThreads = 2;
|
|
|
++ Display *dpy = NULL;
|
|
|
++ int i;
|
|
|
++ Status threadStat;
|
|
|
++
|
|
|
++ if (argc == 1) {
|
|
|
++ usage();
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ int i;
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
|
|
|
++ displayName = argv[i + 1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-p") == 0) {
|
|
|
++ MultiDisplays = 1;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-l") == 0) {
|
|
|
++ Locking = 1;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-t") == 0) {
|
|
|
++ Texture = 1;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-n") == 0 && i + 1 < argc) {
|
|
|
++ numThreads = atoi(argv[i + 1]);
|
|
|
++ if (numThreads < 1)
|
|
|
++ numThreads = 1;
|
|
|
++ else if (numThreads > MAX_WINTHREADS)
|
|
|
++ numThreads = MAX_WINTHREADS;
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ usage();
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if (Locking)
|
|
|
++ printf("glthreads: Using explicit locks around Xlib calls.\n");
|
|
|
++ else
|
|
|
++ printf("glthreads: No explict locking.\n");
|
|
|
++
|
|
|
++ if (MultiDisplays)
|
|
|
++ printf("glthreads: Per-thread display connections.\n");
|
|
|
++ else
|
|
|
++ printf("glthreads: Single display connection.\n");
|
|
|
++
|
|
|
++ /*
|
|
|
++ * VERY IMPORTANT: call XInitThreads() before any other Xlib functions.
|
|
|
++ */
|
|
|
++ if (!MultiDisplays) {
|
|
|
++ if (!Locking) {
|
|
|
++ threadStat = XInitThreads();
|
|
|
++ if (threadStat) {
|
|
|
++ printf("XInitThreads() returned %d (success)\n", (int) threadStat);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("XInitThreads() returned 0 (failure- this program may fail)\n");
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(displayName);
|
|
|
++ if (!dpy) {
|
|
|
++ fprintf(stderr, "Unable to open display %s\n", XDisplayName(displayName));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ pthread_mutex_init(&Mutex, NULL);
|
|
|
++ pthread_mutex_init(&CondMutex, NULL);
|
|
|
++ pthread_cond_init(&CondVar, NULL);
|
|
|
++
|
|
|
++ printf("glthreads: creating windows\n");
|
|
|
++
|
|
|
++ NumWinThreads = numThreads;
|
|
|
++
|
|
|
++ /* Create the GLX windows and contexts */
|
|
|
++ for (i = 0; i < numThreads; i++) {
|
|
|
++ GLXContext share;
|
|
|
++
|
|
|
++ if (MultiDisplays) {
|
|
|
++ WinThreads[i].Dpy = XOpenDisplay(displayName);
|
|
|
++ assert(WinThreads[i].Dpy);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ WinThreads[i].Dpy = dpy;
|
|
|
++ }
|
|
|
++ WinThreads[i].Index = i;
|
|
|
++ WinThreads[i].Initialized = GL_FALSE;
|
|
|
++
|
|
|
++ share = (Texture && i > 0) ? WinThreads[0].Context : 0;
|
|
|
++
|
|
|
++ create_window(&WinThreads[i], share);
|
|
|
++ }
|
|
|
++
|
|
|
++ printf("glthreads: creating threads\n");
|
|
|
++
|
|
|
++ /* Create the threads */
|
|
|
++ for (i = 0; i < numThreads; i++) {
|
|
|
++ pthread_create(&WinThreads[i].Thread, NULL, thread_function,
|
|
|
++ (void*) &WinThreads[i]);
|
|
|
++ printf("glthreads: Created thread %p\n", (void *) WinThreads[i].Thread);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (MultiDisplays)
|
|
|
++ event_loop_multi();
|
|
|
++ else
|
|
|
++ event_loop(dpy);
|
|
|
++
|
|
|
++ clean_up();
|
|
|
++
|
|
|
++ if (MultiDisplays) {
|
|
|
++ for (i = 0; i < numThreads; i++) {
|
|
|
++ XCloseDisplay(WinThreads[i].Dpy);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++ }
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++#else /* PTHREADS */
|
|
|
++
|
|
|
++
|
|
|
++#include <stdio.h>
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ printf("Sorry, this program wasn't compiled with PTHREADS defined.\n");
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++#endif /* PTHREADS */
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxcontexts.c Mesa-7.8.1.patched/progs/xdemos/glxcontexts.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxcontexts.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxcontexts.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,548 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++/*
|
|
|
++ * Version of glxgears that creates/destroys the rendering context for each
|
|
|
++ * frame. Also periodically destroy/recreate the window.
|
|
|
++ * Good for finding memory leaks, etc.
|
|
|
++ *
|
|
|
++ * Command line options:
|
|
|
++ * -info print GL implementation information
|
|
|
++ *
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <assert.h>
|
|
|
++#include <math.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++
|
|
|
++#define BENCHMARK
|
|
|
++
|
|
|
++#ifdef BENCHMARK
|
|
|
++
|
|
|
++/* XXX this probably isn't very portable */
|
|
|
++
|
|
|
++#include <sys/time.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++/* return current time (in seconds) */
|
|
|
++static double
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ struct timeval tv;
|
|
|
++#ifdef __VMS
|
|
|
++ (void) gettimeofday(&tv, NULL );
|
|
|
++#else
|
|
|
++ struct timezone tz;
|
|
|
++ (void) gettimeofday(&tv, &tz);
|
|
|
++#endif
|
|
|
++ return (double) tv.tv_sec + tv.tv_usec / 1000000.0;
|
|
|
++}
|
|
|
++
|
|
|
++#else /*BENCHMARK*/
|
|
|
++
|
|
|
++/* dummy */
|
|
|
++static double
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ /* update this function for other platforms! */
|
|
|
++ static double t = 0.0;
|
|
|
++ static int warn = 1;
|
|
|
++ if (warn) {
|
|
|
++ fprintf(stderr, "Warning: current_time() not implemented!!\n");
|
|
|
++ warn = 0;
|
|
|
++ }
|
|
|
++ return t += 1.0;
|
|
|
++}
|
|
|
++
|
|
|
++#endif /*BENCHMARK*/
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++#ifndef M_PI
|
|
|
++#define M_PI 3.14159265
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
|
|
|
++static GLint gear1, gear2, gear3;
|
|
|
++static GLfloat angle = 0.0;
|
|
|
++
|
|
|
++static XVisualInfo *visinfo = NULL;
|
|
|
++static int WinWidth = 300, WinHeight = 300;
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ *
|
|
|
++ * Draw a gear wheel. You'll probably want to call this function when
|
|
|
++ * building a display list since we do a lot of trig here.
|
|
|
++ *
|
|
|
++ * Input: inner_radius - radius of hole at center
|
|
|
++ * outer_radius - radius at center of teeth
|
|
|
++ * width - width of gear
|
|
|
++ * teeth - number of teeth
|
|
|
++ * tooth_depth - depth of tooth
|
|
|
++ */
|
|
|
++static void
|
|
|
++gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
|
|
|
++ GLint teeth, GLfloat tooth_depth)
|
|
|
++{
|
|
|
++ GLint i;
|
|
|
++ GLfloat r0, r1, r2;
|
|
|
++ GLfloat angle, da;
|
|
|
++ GLfloat u, v, len;
|
|
|
++
|
|
|
++ r0 = inner_radius;
|
|
|
++ r1 = outer_radius - tooth_depth / 2.0;
|
|
|
++ r2 = outer_radius + tooth_depth / 2.0;
|
|
|
++
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ /* draw front face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw front sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, -1.0);
|
|
|
++
|
|
|
++ /* draw back face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw back sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw outward faces of teeth */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ u = r2 * cos(angle + da) - r1 * cos(angle);
|
|
|
++ v = r2 * sin(angle + da) - r1 * sin(angle);
|
|
|
++ len = sqrt(u * u + v * v);
|
|
|
++ u /= len;
|
|
|
++ v /= len;
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
|
|
|
++ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glShadeModel(GL_SMOOTH);
|
|
|
++
|
|
|
++ /* draw inside radius cylinder */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glNormal3f(-cos(angle), -sin(angle), 0.0);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++do_draw(void)
|
|
|
++{
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(view_rotx, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(view_roty, 0.0, 1.0, 0.0);
|
|
|
++ glRotatef(view_rotz, 0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.0, -2.0, 0.0);
|
|
|
++ glRotatef(angle, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear1);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(3.1, -2.0, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear2);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.1, 4.2, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear3);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* new window size or exposure */
|
|
|
++static void
|
|
|
++reshape(int width, int height)
|
|
|
++{
|
|
|
++ glViewport(0, 0, (GLint) width, (GLint) height);
|
|
|
++
|
|
|
++ {
|
|
|
++ GLfloat h = (GLfloat) height / (GLfloat) width;
|
|
|
++
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -40.0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++init(void)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
|
|
|
++ static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
|
|
|
++ static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
|
|
|
++ static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
|
|
|
++
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ /* make the gears */
|
|
|
++ gear1 = glGenLists(1);
|
|
|
++ glNewList(gear1, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
|
|
|
++ gear(1.0, 4.0, 1.0, 20, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear2 = glGenLists(1);
|
|
|
++ glNewList(gear2, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
|
|
|
++ gear(0.5, 2.0, 2.0, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear3 = glGenLists(1);
|
|
|
++ glNewList(gear3, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
|
|
|
++ gear(1.3, 2.0, 0.5, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw( Display *dpy, Window win )
|
|
|
++{
|
|
|
++ GLXContext ctx;
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, win, ctx);
|
|
|
++
|
|
|
++ init();
|
|
|
++
|
|
|
++ reshape(WinWidth, WinHeight);
|
|
|
++
|
|
|
++ do_draw();
|
|
|
++
|
|
|
++ glDeleteLists(gear1, 1);
|
|
|
++ glDeleteLists(gear2, 1);
|
|
|
++ glDeleteLists(gear3, 1);
|
|
|
++
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window( Display *dpy, const char *name,
|
|
|
++ int x, int y, int width, int height,
|
|
|
++ Window *winRet)
|
|
|
++{
|
|
|
++ int attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ if (visinfo)
|
|
|
++ XFree(visinfo);
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attribs );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ attr.override_redirect = 0;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, x, y, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ *winRet = win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy)
|
|
|
++{
|
|
|
++ Window win;
|
|
|
++ make_window(dpy, "glxgears", 0, 0, WinWidth, WinHeight, &win);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ while (XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ /* we'll redraw below */
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ WinWidth = event.xconfigure.width;
|
|
|
++ WinHeight = event.xconfigure.height;
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ view_roty += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Right) {
|
|
|
++ view_roty -= 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Up) {
|
|
|
++ view_rotx += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Down) {
|
|
|
++ view_rotx -= 5.0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ {
|
|
|
++ static int frames = 0;
|
|
|
++ static double tRot0 = -1.0, tRate0 = -1.0;
|
|
|
++ double dt, t = current_time();
|
|
|
++ if (tRot0 < 0.0)
|
|
|
++ tRot0 = t;
|
|
|
++ dt = t - tRot0;
|
|
|
++ tRot0 = t;
|
|
|
++
|
|
|
++ /* advance rotation for next frame */
|
|
|
++ angle += 70.0 * dt; /* 70 degrees per second */
|
|
|
++ if (angle > 3600.0)
|
|
|
++ angle -= 3600.0;
|
|
|
++
|
|
|
++ draw( dpy, win );
|
|
|
++
|
|
|
++ frames++;
|
|
|
++
|
|
|
++ if (tRate0 < 0.0)
|
|
|
++ tRate0 = t;
|
|
|
++
|
|
|
++ if (t - tRate0 >= 1.0) {
|
|
|
++ GLfloat seconds = t - tRate0;
|
|
|
++ GLfloat fps = frames / seconds;
|
|
|
++ printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
|
|
|
++ fps);
|
|
|
++ tRate0 = t;
|
|
|
++
|
|
|
++ /* Destroy window and create new one */
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++ make_window(dpy, "glxgears",
|
|
|
++ (int)(fps * 100) % 100, (int)(fps * 100) % 100, /* x,y */
|
|
|
++ WinWidth, WinHeight, &win);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ frames = 0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ char *dpyName = NULL;
|
|
|
++ GLboolean printInfo = GL_FALSE;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-info") == 0) {
|
|
|
++ printInfo = GL_TRUE;
|
|
|
++ }
|
|
|
++ else
|
|
|
++ printf("Warrning: unknown parameter: %s\n", argv[i]);
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ fprintf(stderr, "Error: couldn't open display %s\n",
|
|
|
++ XDisplayName(dpyName));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (printInfo) {
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
|
|
|
++ }
|
|
|
++
|
|
|
++ event_loop(dpy);
|
|
|
++
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxdemo.c Mesa-7.8.1.patched/progs/xdemos/glxdemo.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxdemo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxdemo.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,127 @@
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * A demonstration of using the GLX functions. This program is in the
|
|
|
++ * public domain.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ */
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void redraw( Display *dpy, Window w )
|
|
|
++{
|
|
|
++ printf("Redraw event\n");
|
|
|
++
|
|
|
++ glClear( GL_COLOR_BUFFER_BIT );
|
|
|
++
|
|
|
++ glColor3f( 1.0, 1.0, 0.0 );
|
|
|
++ glRectf( -0.8, -0.8, 0.8, 0.8 );
|
|
|
++
|
|
|
++ glXSwapBuffers( dpy, w );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void resize( unsigned int width, unsigned int height )
|
|
|
++{
|
|
|
++ printf("Resize event\n");
|
|
|
++ glViewport( 0, 0, width, height );
|
|
|
++ glMatrixMode( GL_PROJECTION );
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho( -1.0, 1.0, -1.0, 1.0, -1.0, 1.0 );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static Window make_rgb_db_window( Display *dpy,
|
|
|
++ 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;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attrib );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXMakeCurrent( dpy, win, ctx );
|
|
|
++
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void event_loop( Display *dpy )
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ XNextEvent( dpy, &event );
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ redraw( dpy, event.xany.window );
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ resize( event.xconfigure.width, event.xconfigure.height );
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int main( int argc, char *argv[] )
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++
|
|
|
++ win = make_rgb_db_window( dpy, 300, 300 );
|
|
|
++
|
|
|
++ glShadeModel( GL_FLAT );
|
|
|
++ glClearColor( 0.5, 0.5, 0.5, 1.0 );
|
|
|
++
|
|
|
++ XMapWindow( dpy, win );
|
|
|
++
|
|
|
++ event_loop( dpy );
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxgears.c Mesa-7.8.1.patched/progs/xdemos/glxgears.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxgears.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxgears.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,787 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++/*
|
|
|
++ * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT)
|
|
|
++ * Port by Brian Paul 23 March 2001
|
|
|
++ *
|
|
|
++ * See usage() below for command line options.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <math.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <GL/glxext.h>
|
|
|
++
|
|
|
++#ifndef GLX_MESA_swap_control
|
|
|
++#define GLX_MESA_swap_control 1
|
|
|
++typedef int (*PFNGLXGETSWAPINTERVALMESAPROC)(void);
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++#define BENCHMARK
|
|
|
++
|
|
|
++#ifdef BENCHMARK
|
|
|
++
|
|
|
++/* XXX this probably isn't very portable */
|
|
|
++
|
|
|
++#include <sys/time.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++/* return current time (in seconds) */
|
|
|
++static double
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ struct timeval tv;
|
|
|
++#ifdef __VMS
|
|
|
++ (void) gettimeofday(&tv, NULL );
|
|
|
++#else
|
|
|
++ struct timezone tz;
|
|
|
++ (void) gettimeofday(&tv, &tz);
|
|
|
++#endif
|
|
|
++ return (double) tv.tv_sec + tv.tv_usec / 1000000.0;
|
|
|
++}
|
|
|
++
|
|
|
++#else /*BENCHMARK*/
|
|
|
++
|
|
|
++/* dummy */
|
|
|
++static double
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ /* update this function for other platforms! */
|
|
|
++ static double t = 0.0;
|
|
|
++ static int warn = 1;
|
|
|
++ if (warn) {
|
|
|
++ fprintf(stderr, "Warning: current_time() not implemented!!\n");
|
|
|
++ warn = 0;
|
|
|
++ }
|
|
|
++ return t += 1.0;
|
|
|
++}
|
|
|
++
|
|
|
++#endif /*BENCHMARK*/
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++#ifndef M_PI
|
|
|
++#define M_PI 3.14159265
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++/** Event handler results: */
|
|
|
++#define NOP 0
|
|
|
++#define EXIT 1
|
|
|
++#define DRAW 2
|
|
|
++
|
|
|
++static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
|
|
|
++static GLint gear1, gear2, gear3;
|
|
|
++static GLfloat angle = 0.0;
|
|
|
++
|
|
|
++static GLboolean fullscreen = GL_FALSE; /* Create a single fullscreen window */
|
|
|
++static GLboolean stereo = GL_FALSE; /* Enable stereo. */
|
|
|
++static GLboolean animate = GL_TRUE; /* Animation */
|
|
|
++static GLfloat eyesep = 5.0; /* Eye separation. */
|
|
|
++static GLfloat fix_point = 40.0; /* Fixation point distance. */
|
|
|
++static GLfloat left, right, asp; /* Stereo frustum params. */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ *
|
|
|
++ * Draw a gear wheel. You'll probably want to call this function when
|
|
|
++ * building a display list since we do a lot of trig here.
|
|
|
++ *
|
|
|
++ * Input: inner_radius - radius of hole at center
|
|
|
++ * outer_radius - radius at center of teeth
|
|
|
++ * width - width of gear
|
|
|
++ * teeth - number of teeth
|
|
|
++ * tooth_depth - depth of tooth
|
|
|
++ */
|
|
|
++static void
|
|
|
++gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
|
|
|
++ GLint teeth, GLfloat tooth_depth)
|
|
|
++{
|
|
|
++ GLint i;
|
|
|
++ GLfloat r0, r1, r2;
|
|
|
++ GLfloat angle, da;
|
|
|
++ GLfloat u, v, len;
|
|
|
++
|
|
|
++ r0 = inner_radius;
|
|
|
++ r1 = outer_radius - tooth_depth / 2.0;
|
|
|
++ r2 = outer_radius + tooth_depth / 2.0;
|
|
|
++
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ /* draw front face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw front sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, -1.0);
|
|
|
++
|
|
|
++ /* draw back face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw back sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw outward faces of teeth */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ u = r2 * cos(angle + da) - r1 * cos(angle);
|
|
|
++ v = r2 * sin(angle + da) - r1 * sin(angle);
|
|
|
++ len = sqrt(u * u + v * v);
|
|
|
++ u /= len;
|
|
|
++ v /= len;
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
|
|
|
++ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glShadeModel(GL_SMOOTH);
|
|
|
++
|
|
|
++ /* draw inside radius cylinder */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glNormal3f(-cos(angle), -sin(angle), 0.0);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw(void)
|
|
|
++{
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(view_rotx, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(view_roty, 0.0, 1.0, 0.0);
|
|
|
++ glRotatef(view_rotz, 0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.0, -2.0, 0.0);
|
|
|
++ glRotatef(angle, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear1);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(3.1, -2.0, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear2);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.1, 4.2, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear3);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw_gears(void)
|
|
|
++{
|
|
|
++ if (stereo) {
|
|
|
++ /* First left eye. */
|
|
|
++ glDrawBuffer(GL_BACK_LEFT);
|
|
|
++
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(left, right, -asp, asp, 5.0, 60.0);
|
|
|
++
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslated(+0.5 * eyesep, 0.0, 0.0);
|
|
|
++ draw();
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ /* Then right eye. */
|
|
|
++ glDrawBuffer(GL_BACK_RIGHT);
|
|
|
++
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-right, -left, -asp, asp, 5.0, 60.0);
|
|
|
++
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslated(-0.5 * eyesep, 0.0, 0.0);
|
|
|
++ draw();
|
|
|
++ glPopMatrix();
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ draw();
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/** Draw single frame, do SwapBuffers, compute FPS */
|
|
|
++static void
|
|
|
++draw_frame(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ static int frames = 0;
|
|
|
++ static double tRot0 = -1.0, tRate0 = -1.0;
|
|
|
++ double dt, t = current_time();
|
|
|
++
|
|
|
++ if (tRot0 < 0.0)
|
|
|
++ tRot0 = t;
|
|
|
++ dt = t - tRot0;
|
|
|
++ tRot0 = t;
|
|
|
++
|
|
|
++ if (animate) {
|
|
|
++ /* advance rotation for next frame */
|
|
|
++ angle += 70.0 * dt; /* 70 degrees per second */
|
|
|
++ if (angle > 3600.0)
|
|
|
++ angle -= 3600.0;
|
|
|
++ }
|
|
|
++
|
|
|
++ draw_gears();
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++
|
|
|
++ frames++;
|
|
|
++
|
|
|
++ if (tRate0 < 0.0)
|
|
|
++ tRate0 = t;
|
|
|
++ if (t - tRate0 >= 5.0) {
|
|
|
++ GLfloat seconds = t - tRate0;
|
|
|
++ GLfloat fps = frames / seconds;
|
|
|
++ printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
|
|
|
++ fps);
|
|
|
++ tRate0 = t;
|
|
|
++ frames = 0;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* new window size or exposure */
|
|
|
++static void
|
|
|
++reshape(int width, int height)
|
|
|
++{
|
|
|
++ glViewport(0, 0, (GLint) width, (GLint) height);
|
|
|
++
|
|
|
++ if (stereo) {
|
|
|
++ GLfloat w;
|
|
|
++
|
|
|
++ asp = (GLfloat) height / (GLfloat) width;
|
|
|
++ w = fix_point * (1.0 / 5.0);
|
|
|
++
|
|
|
++ left = -5.0 * ((w - 0.5 * eyesep) / fix_point);
|
|
|
++ right = 5.0 * ((w + 0.5 * eyesep) / fix_point);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ GLfloat h = (GLfloat) height / (GLfloat) width;
|
|
|
++
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -40.0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++init(void)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
|
|
|
++ static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
|
|
|
++ static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
|
|
|
++ static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
|
|
|
++
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ /* make the gears */
|
|
|
++ gear1 = glGenLists(1);
|
|
|
++ glNewList(gear1, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
|
|
|
++ gear(1.0, 4.0, 1.0, 20, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear2 = glGenLists(1);
|
|
|
++ glNewList(gear2, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
|
|
|
++ gear(0.5, 2.0, 2.0, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear3 = glGenLists(1);
|
|
|
++ glNewList(gear3, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
|
|
|
++ gear(1.3, 2.0, 0.5, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Remove window border/decorations.
|
|
|
++ */
|
|
|
++static void
|
|
|
++no_border( Display *dpy, Window w)
|
|
|
++{
|
|
|
++ static const unsigned MWM_HINTS_DECORATIONS = (1 << 1);
|
|
|
++ static const int PROP_MOTIF_WM_HINTS_ELEMENTS = 5;
|
|
|
++
|
|
|
++ typedef struct
|
|
|
++ {
|
|
|
++ unsigned long flags;
|
|
|
++ unsigned long functions;
|
|
|
++ unsigned long decorations;
|
|
|
++ long inputMode;
|
|
|
++ unsigned long status;
|
|
|
++ } PropMotifWmHints;
|
|
|
++
|
|
|
++ PropMotifWmHints motif_hints;
|
|
|
++ Atom prop, proptype;
|
|
|
++ unsigned long flags = 0;
|
|
|
++
|
|
|
++ /* setup the property */
|
|
|
++ motif_hints.flags = MWM_HINTS_DECORATIONS;
|
|
|
++ motif_hints.decorations = flags;
|
|
|
++
|
|
|
++ /* get the atom for the property */
|
|
|
++ prop = XInternAtom( dpy, "_MOTIF_WM_HINTS", True );
|
|
|
++ if (!prop) {
|
|
|
++ /* something went wrong! */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* not sure this is correct, seems to work, XA_WM_HINTS didn't work */
|
|
|
++ proptype = prop;
|
|
|
++
|
|
|
++ XChangeProperty( dpy, w, /* display, window */
|
|
|
++ prop, proptype, /* property, type */
|
|
|
++ 32, /* format: 32-bit datums */
|
|
|
++ PropModeReplace, /* mode */
|
|
|
++ (unsigned char *) &motif_hints, /* data */
|
|
|
++ PROP_MOTIF_WM_HINTS_ELEMENTS /* nelements */
|
|
|
++ );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window( Display *dpy, const char *name,
|
|
|
++ int x, int y, int width, int height,
|
|
|
++ Window *winRet, GLXContext *ctxRet)
|
|
|
++{
|
|
|
++ int attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int stereoAttribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ GLX_STEREO,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ if (fullscreen) {
|
|
|
++ x = 0; y = 0;
|
|
|
++ width = DisplayWidth( dpy, scrnum );
|
|
|
++ height = DisplayHeight( dpy, scrnum );
|
|
|
++ }
|
|
|
++
|
|
|
++ if (stereo)
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, stereoAttribs );
|
|
|
++ else
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attribs );
|
|
|
++ if (!visinfo) {
|
|
|
++ if (stereo) {
|
|
|
++ printf("Error: couldn't get an RGB, "
|
|
|
++ "Double-buffered, Stereo visual\n");
|
|
|
++ } else
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ /* XXX this is a bad way to get a borderless window! */
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, x, y, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ if (fullscreen)
|
|
|
++ no_border(dpy, win);
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(visinfo);
|
|
|
++
|
|
|
++ *winRet = win;
|
|
|
++ *ctxRet = ctx;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Determine whether or not a GLX extension is supported.
|
|
|
++ */
|
|
|
++static int
|
|
|
++is_glx_extension_supported(Display *dpy, const char *query)
|
|
|
++{
|
|
|
++ const int scrnum = DefaultScreen(dpy);
|
|
|
++ const char *glx_extensions = NULL;
|
|
|
++ const size_t len = strlen(query);
|
|
|
++ const char *ptr;
|
|
|
++
|
|
|
++ if (glx_extensions == NULL) {
|
|
|
++ glx_extensions = glXQueryExtensionsString(dpy, scrnum);
|
|
|
++ }
|
|
|
++
|
|
|
++ ptr = strstr(glx_extensions, query);
|
|
|
++ return ((ptr != NULL) && ((ptr[len] == ' ') || (ptr[len] == '\0')));
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Attempt to determine whether or not the display is synched to vblank.
|
|
|
++ */
|
|
|
++static void
|
|
|
++query_vsync(Display *dpy, GLXDrawable drawable)
|
|
|
++{
|
|
|
++ int interval = 0;
|
|
|
++
|
|
|
++#if defined(GLX_EXT_swap_control)
|
|
|
++ if (is_glx_extension_supported(dpy, "GLX_EXT_swap_control")) {
|
|
|
++ unsigned int tmp = -1;
|
|
|
++ glXQueryDrawable(dpy, drawable, GLX_SWAP_INTERVAL_EXT, &tmp);
|
|
|
++ interval = tmp;
|
|
|
++ } else
|
|
|
++#endif
|
|
|
++ if (is_glx_extension_supported(dpy, "GLX_MESA_swap_control")) {
|
|
|
++ PFNGLXGETSWAPINTERVALMESAPROC pglXGetSwapIntervalMESA =
|
|
|
++ (PFNGLXGETSWAPINTERVALMESAPROC)
|
|
|
++ glXGetProcAddressARB((const GLubyte *) "glXGetSwapIntervalMESA");
|
|
|
++
|
|
|
++ interval = (*pglXGetSwapIntervalMESA)();
|
|
|
++ } else if (is_glx_extension_supported(dpy, "GLX_SGI_swap_control")) {
|
|
|
++ /* The default swap interval with this extension is 1. Assume that it
|
|
|
++ * is set to the default.
|
|
|
++ *
|
|
|
++ * Many Mesa-based drivers default to 0, but all of these drivers also
|
|
|
++ * export GLX_MESA_swap_control. In that case, this branch will never
|
|
|
++ * be taken, and the correct result should be reported.
|
|
|
++ */
|
|
|
++ interval = 1;
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ if (interval > 0) {
|
|
|
++ printf("Running synchronized to the vertical refresh. The framerate should be\n");
|
|
|
++ if (interval == 1) {
|
|
|
++ printf("approximately the same as the monitor refresh rate.\n");
|
|
|
++ } else if (interval > 1) {
|
|
|
++ printf("approximately 1/%d the monitor refresh rate.\n",
|
|
|
++ interval);
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++/**
|
|
|
++ * Handle one X event.
|
|
|
++ * \return NOP, EXIT or DRAW
|
|
|
++ */
|
|
|
++static int
|
|
|
++handle_event(Display *dpy, Window win, XEvent *event)
|
|
|
++{
|
|
|
++ (void) dpy;
|
|
|
++ (void) win;
|
|
|
++
|
|
|
++ switch (event->type) {
|
|
|
++ case Expose:
|
|
|
++ return DRAW;
|
|
|
++ case ConfigureNotify:
|
|
|
++ reshape(event->xconfigure.width, event->xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event->xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ view_roty += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Right) {
|
|
|
++ view_roty -= 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Up) {
|
|
|
++ view_rotx += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Down) {
|
|
|
++ view_rotx -= 5.0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event->xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return EXIT;
|
|
|
++ }
|
|
|
++ else if (buffer[0] == 'a' || buffer[0] == 'A') {
|
|
|
++ animate = !animate;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ return DRAW;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ return NOP;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ int op;
|
|
|
++ while (!animate || XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ op = handle_event(dpy, win, &event);
|
|
|
++ if (op == EXIT)
|
|
|
++ return;
|
|
|
++ else if (op == DRAW)
|
|
|
++ break;
|
|
|
++ }
|
|
|
++
|
|
|
++ draw_frame(dpy, win);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++usage(void)
|
|
|
++{
|
|
|
++ printf("Usage:\n");
|
|
|
++ printf(" -display <displayname> set the display to run on\n");
|
|
|
++ printf(" -stereo run in stereo mode\n");
|
|
|
++ printf(" -fullscreen run in fullscreen mode\n");
|
|
|
++ printf(" -info display OpenGL renderer info\n");
|
|
|
++ printf(" -geometry WxH+X+Y window geometry\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ unsigned int winWidth = 300, winHeight = 300;
|
|
|
++ int x = 0, y = 0;
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ char *dpyName = NULL;
|
|
|
++ GLboolean printInfo = GL_FALSE;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-info") == 0) {
|
|
|
++ printInfo = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-stereo") == 0) {
|
|
|
++ stereo = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-fullscreen") == 0) {
|
|
|
++ fullscreen = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (i < argc-1 && strcmp(argv[i], "-geometry") == 0) {
|
|
|
++ XParseGeometry(argv[i+1], &x, &y, &winWidth, &winHeight);
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ usage();
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n",
|
|
|
++ dpyName ? dpyName : getenv("DISPLAY"));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ make_window(dpy, "glxgears", x, y, winWidth, winHeight, &win, &ctx);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ glXMakeCurrent(dpy, win, ctx);
|
|
|
++ query_vsync(dpy, win);
|
|
|
++
|
|
|
++ if (printInfo) {
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
|
|
|
++ }
|
|
|
++
|
|
|
++ init();
|
|
|
++
|
|
|
++ /* Set initial projection/viewing transformation.
|
|
|
++ * We can't be sure we'll get a ConfigureNotify event when the window
|
|
|
++ * first appears.
|
|
|
++ */
|
|
|
++ reshape(winWidth, winHeight);
|
|
|
++
|
|
|
++ event_loop(dpy, win);
|
|
|
++
|
|
|
++ glDeleteLists(gear1, 1);
|
|
|
++ glDeleteLists(gear2, 1);
|
|
|
++ glDeleteLists(gear3, 1);
|
|
|
++ glXMakeCurrent(dpy, None, NULL);
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxgears_fbconfig.c Mesa-7.8.1.patched/progs/xdemos/glxgears_fbconfig.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxgears_fbconfig.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxgears_fbconfig.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,632 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++/**
|
|
|
++ * \file glxgears_fbconfig.c
|
|
|
++ * Yet-another-version of gears. Originally ported to GLX by Brian Paul on
|
|
|
++ * 23 March 2001. Modified to use fbconfigs by Ian Romanick on 10 Feb 2004.
|
|
|
++ *
|
|
|
++ * Command line options:
|
|
|
++ * -info print GL implementation information
|
|
|
++ *
|
|
|
++ * \author Brian Paul
|
|
|
++ * \author Ian Romanick <idr@us.ibm.com>
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#define GLX_GLXEXT_PROTOTYPES
|
|
|
++
|
|
|
++#include <math.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <GL/glxext.h>
|
|
|
++#include <assert.h>
|
|
|
++#include "pbutil.h"
|
|
|
++
|
|
|
++static PFNGLXCHOOSEFBCONFIGPROC choose_fbconfig = NULL;
|
|
|
++static PFNGLXGETVISUALFROMFBCONFIGPROC get_visual_from_fbconfig = NULL;
|
|
|
++static PFNGLXCREATENEWCONTEXTPROC create_new_context = NULL;
|
|
|
++static PFNGLXCREATEWINDOWPROC create_window = NULL;
|
|
|
++static PFNGLXDESTROYWINDOWPROC destroy_window = NULL;
|
|
|
++
|
|
|
++#define BENCHMARK
|
|
|
++
|
|
|
++#ifdef BENCHMARK
|
|
|
++
|
|
|
++/* XXX this probably isn't very portable */
|
|
|
++
|
|
|
++#include <sys/time.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++/* return current time (in seconds) */
|
|
|
++static int
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ struct timeval tv;
|
|
|
++#ifdef __VMS
|
|
|
++ (void) gettimeofday(&tv, NULL );
|
|
|
++#else
|
|
|
++ struct timezone tz;
|
|
|
++ (void) gettimeofday(&tv, &tz);
|
|
|
++#endif
|
|
|
++ return (int) tv.tv_sec;
|
|
|
++}
|
|
|
++
|
|
|
++#else /*BENCHMARK*/
|
|
|
++
|
|
|
++/* dummy */
|
|
|
++static int
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++#endif /*BENCHMARK*/
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++#ifndef M_PI
|
|
|
++#define M_PI 3.14159265
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
|
|
|
++static GLint gear1, gear2, gear3;
|
|
|
++static GLfloat angle = 0.0;
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ *
|
|
|
++ * Draw a gear wheel. You'll probably want to call this function when
|
|
|
++ * building a display list since we do a lot of trig here.
|
|
|
++ *
|
|
|
++ * Input: inner_radius - radius of hole at center
|
|
|
++ * outer_radius - radius at center of teeth
|
|
|
++ * width - width of gear
|
|
|
++ * teeth - number of teeth
|
|
|
++ * tooth_depth - depth of tooth
|
|
|
++ */
|
|
|
++static void
|
|
|
++gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
|
|
|
++ GLint teeth, GLfloat tooth_depth)
|
|
|
++{
|
|
|
++ GLint i;
|
|
|
++ GLfloat r0, r1, r2;
|
|
|
++ GLfloat angle, da;
|
|
|
++ GLfloat u, v, len;
|
|
|
++
|
|
|
++ r0 = inner_radius;
|
|
|
++ r1 = outer_radius - tooth_depth / 2.0;
|
|
|
++ r2 = outer_radius + tooth_depth / 2.0;
|
|
|
++
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ /* draw front face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw front sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, -1.0);
|
|
|
++
|
|
|
++ /* draw back face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw back sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw outward faces of teeth */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ u = r2 * cos(angle + da) - r1 * cos(angle);
|
|
|
++ v = r2 * sin(angle + da) - r1 * sin(angle);
|
|
|
++ len = sqrt(u * u + v * v);
|
|
|
++ u /= len;
|
|
|
++ v /= len;
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
|
|
|
++ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glShadeModel(GL_SMOOTH);
|
|
|
++
|
|
|
++ /* draw inside radius cylinder */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glNormal3f(-cos(angle), -sin(angle), 0.0);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw(void)
|
|
|
++{
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(view_rotx, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(view_roty, 0.0, 1.0, 0.0);
|
|
|
++ glRotatef(view_rotz, 0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.0, -2.0, 0.0);
|
|
|
++ glRotatef(angle, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear1);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(3.1, -2.0, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear2);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.1, 4.2, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear3);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* new window size or exposure */
|
|
|
++static void
|
|
|
++reshape(int width, int height)
|
|
|
++{
|
|
|
++ GLfloat h = (GLfloat) height / (GLfloat) width;
|
|
|
++
|
|
|
++ glViewport(0, 0, (GLint) width, (GLint) height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -40.0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++init(void)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
|
|
|
++ static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
|
|
|
++ static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
|
|
|
++ static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
|
|
|
++
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ /* make the gears */
|
|
|
++ gear1 = glGenLists(1);
|
|
|
++ glNewList(gear1, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
|
|
|
++ gear(1.0, 4.0, 1.0, 20, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear2 = glGenLists(1);
|
|
|
++ glNewList(gear2, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
|
|
|
++ gear(0.5, 2.0, 2.0, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear3 = glGenLists(1);
|
|
|
++ glNewList(gear3, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
|
|
|
++ gear(1.3, 2.0, 0.5, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static GLXWindow
|
|
|
++dummy_create_window(Display *dpy, GLXFBConfig config, Window win,
|
|
|
++ const int *attrib_list)
|
|
|
++{
|
|
|
++ (void) dpy;
|
|
|
++ (void) config;
|
|
|
++ (void) attrib_list;
|
|
|
++
|
|
|
++ return (GLXWindow) win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++dummy_destroy_window(Display *dpy, GLXWindow win)
|
|
|
++{
|
|
|
++ (void) dpy;
|
|
|
++ (void) win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Initialize fbconfig related function pointers.
|
|
|
++ */
|
|
|
++static void
|
|
|
++init_fbconfig_functions(Display *dpy, int scrnum)
|
|
|
++{
|
|
|
++ const char * glx_extensions;
|
|
|
++ const char * match;
|
|
|
++ static const char ext_name[] = "GLX_SGIX_fbconfig";
|
|
|
++ const size_t len = strlen( ext_name );
|
|
|
++ int major;
|
|
|
++ int minor;
|
|
|
++ GLboolean ext_version_supported;
|
|
|
++ GLboolean glx_1_3_supported;
|
|
|
++
|
|
|
++
|
|
|
++ /* Determine if GLX 1.3 or greater is supported.
|
|
|
++ */
|
|
|
++ glXQueryVersion(dpy, & major, & minor);
|
|
|
++ glx_1_3_supported = (major == 1) && (minor >= 3);
|
|
|
++
|
|
|
++ /* Determine if GLX_SGIX_fbconfig is supported.
|
|
|
++ */
|
|
|
++ glx_extensions = glXQueryExtensionsString(dpy, scrnum);
|
|
|
++ match = strstr( glx_extensions, ext_name );
|
|
|
++
|
|
|
++ ext_version_supported = (match != NULL)
|
|
|
++ && ((match[len] == '\0') || (match[len] == ' '));
|
|
|
++
|
|
|
++ printf( "GLX 1.3 is %ssupported.\n",
|
|
|
++ (glx_1_3_supported) ? "" : "not " );
|
|
|
++ printf( "%s is %ssupported.\n",
|
|
|
++ ext_name, (ext_version_supported) ? "" : "not " );
|
|
|
++
|
|
|
++ if ( glx_1_3_supported ) {
|
|
|
++ choose_fbconfig = (PFNGLXCHOOSEFBCONFIGPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXChooseFBConfig");
|
|
|
++ get_visual_from_fbconfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXGetVisualFromFBConfig");
|
|
|
++ create_new_context = (PFNGLXCREATENEWCONTEXTPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXCreateNewContext");
|
|
|
++ create_window = (PFNGLXCREATEWINDOWPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXCreateWindow");
|
|
|
++ destroy_window = (PFNGLXDESTROYWINDOWPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXDestroyWindow");
|
|
|
++ }
|
|
|
++ else if ( ext_version_supported ) {
|
|
|
++ choose_fbconfig = (PFNGLXCHOOSEFBCONFIGPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXChooseFBConfigSGIX");
|
|
|
++ get_visual_from_fbconfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXGetVisualFromFBConfigSGIX");
|
|
|
++ create_new_context = (PFNGLXCREATENEWCONTEXTPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glXCreateContextWithConfigSGIX");
|
|
|
++ create_window = dummy_create_window;
|
|
|
++ destroy_window = dummy_destroy_window;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf( "This demo requires either GLX 1.3 or %s be supported.\n",
|
|
|
++ ext_name );
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( choose_fbconfig == NULL ) {
|
|
|
++ printf( "glXChooseFBConfig not found!\n" );
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( get_visual_from_fbconfig == NULL ) {
|
|
|
++ printf( "glXGetVisualFromFBConfig not found!\n" );
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( create_new_context == NULL ) {
|
|
|
++ printf( "glXCreateNewContext not found!\n" );
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window( Display *dpy, const char *name,
|
|
|
++ int x, int y, int width, int height,
|
|
|
++ Window *winRet, GLXWindow *glxWinRet, GLXContext *ctxRet)
|
|
|
++{
|
|
|
++ int attrib[] = { GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER, GL_TRUE,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ GLXFBConfig * fbconfig;
|
|
|
++ int num_configs;
|
|
|
++ int scrnum;
|
|
|
++ int i;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXWindow glxWin;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ init_fbconfig_functions(dpy, scrnum);
|
|
|
++ fbconfig = (*choose_fbconfig)(dpy, scrnum, attrib, & num_configs);
|
|
|
++ if (fbconfig == NULL) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ printf("\nThe following fbconfigs meet the requirements. The first one "
|
|
|
++ "will be used.\n\n");
|
|
|
++ for ( i = 0 ; i < num_configs ; i++ ) {
|
|
|
++ PrintFBConfigInfo(dpy, scrnum, fbconfig[i], GL_TRUE);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ visinfo = (*get_visual_from_fbconfig)(dpy, fbconfig[0]);
|
|
|
++ assert(visinfo != NULL);
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ glxWin = (*create_window)(dpy, fbconfig[0], win, NULL);
|
|
|
++
|
|
|
++ ctx = (*create_new_context)(dpy, fbconfig[0], GLX_RGBA_TYPE, NULL, GL_TRUE);
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateNewContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(fbconfig);
|
|
|
++
|
|
|
++ *glxWinRet = glxWin;
|
|
|
++ *winRet = win;
|
|
|
++ *ctxRet = ctx;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy, GLXWindow win)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ while (XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ /* we'll redraw below */
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ reshape(event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ view_roty += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Right) {
|
|
|
++ view_roty -= 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Up) {
|
|
|
++ view_rotx += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Down) {
|
|
|
++ view_rotx -= 5.0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ /* next frame */
|
|
|
++ angle += 2.0;
|
|
|
++
|
|
|
++ draw();
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++
|
|
|
++ /* calc framerate */
|
|
|
++ {
|
|
|
++ static int t0 = -1;
|
|
|
++ static int frames = 0;
|
|
|
++ int t = current_time();
|
|
|
++
|
|
|
++ if (t0 < 0)
|
|
|
++ t0 = t;
|
|
|
++
|
|
|
++ frames++;
|
|
|
++
|
|
|
++ if (t - t0 >= 5.0) {
|
|
|
++ GLfloat seconds = t - t0;
|
|
|
++ GLfloat fps = frames / seconds;
|
|
|
++ printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
|
|
|
++ fps);
|
|
|
++ t0 = t;
|
|
|
++ frames = 0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXWindow glxWin;
|
|
|
++ GLXContext ctx;
|
|
|
++ const char *dpyName = NULL;
|
|
|
++ GLboolean printInfo = GL_FALSE;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-info") == 0) {
|
|
|
++ printInfo = GL_TRUE;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n", XDisplayName(dpyName));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ make_window(dpy, "glxgears", 0, 0, 300, 300, &win, &glxWin, &ctx);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ glXMakeCurrent(dpy, glxWin, ctx);
|
|
|
++
|
|
|
++ if (printInfo) {
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
|
|
|
++ }
|
|
|
++
|
|
|
++ init();
|
|
|
++
|
|
|
++ event_loop(dpy, glxWin);
|
|
|
++
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++ destroy_window(dpy, glxWin);
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxgears_pixmap.c Mesa-7.8.1.patched/progs/xdemos/glxgears_pixmap.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxgears_pixmap.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxgears_pixmap.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,547 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
|
|
|
++ * Copyright (C) 2008 Red Hat, Inc All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++/**
|
|
|
++ * \file glxgears_pixmap.c
|
|
|
++ * Yet-another-version of gears. Originally ported to GLX by Brian Paul on
|
|
|
++ * 23 March 2001. Modified to use fbconfigs by Ian Romanick on 10 Feb 2004.
|
|
|
++ *
|
|
|
++ * Command line options:
|
|
|
++ * -info print GL implementation information
|
|
|
++ *
|
|
|
++ * \author Brian Paul
|
|
|
++ * \author Ian Romanick <idr@us.ibm.com>
|
|
|
++ * \author Kristian Hoegsberg <krh@redhat.com>
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#define GLX_GLXEXT_PROTOTYPES
|
|
|
++
|
|
|
++#include <math.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <GL/glxext.h>
|
|
|
++#include <assert.h>
|
|
|
++#include "pbutil.h"
|
|
|
++
|
|
|
++#define BENCHMARK
|
|
|
++
|
|
|
++#ifdef BENCHMARK
|
|
|
++
|
|
|
++/* XXX this probably isn't very portable */
|
|
|
++
|
|
|
++#include <sys/time.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++/* return current time (in seconds) */
|
|
|
++static int
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ struct timeval tv;
|
|
|
++#ifdef __VMS
|
|
|
++ (void) gettimeofday(&tv, NULL );
|
|
|
++#else
|
|
|
++ struct timezone tz;
|
|
|
++ (void) gettimeofday(&tv, &tz);
|
|
|
++#endif
|
|
|
++ return (int) tv.tv_sec;
|
|
|
++}
|
|
|
++
|
|
|
++#else /*BENCHMARK*/
|
|
|
++
|
|
|
++/* dummy */
|
|
|
++static int
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++#endif /*BENCHMARK*/
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++#ifndef M_PI
|
|
|
++#define M_PI 3.14159265
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
|
|
|
++static GLint gear1, gear2, gear3;
|
|
|
++static GLfloat angle = 0.0;
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ *
|
|
|
++ * Draw a gear wheel. You'll probably want to call this function when
|
|
|
++ * building a display list since we do a lot of trig here.
|
|
|
++ *
|
|
|
++ * Input: inner_radius - radius of hole at center
|
|
|
++ * outer_radius - radius at center of teeth
|
|
|
++ * width - width of gear
|
|
|
++ * teeth - number of teeth
|
|
|
++ * tooth_depth - depth of tooth
|
|
|
++ */
|
|
|
++static void
|
|
|
++gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
|
|
|
++ GLint teeth, GLfloat tooth_depth)
|
|
|
++{
|
|
|
++ GLint i;
|
|
|
++ GLfloat r0, r1, r2;
|
|
|
++ GLfloat angle, da;
|
|
|
++ GLfloat u, v, len;
|
|
|
++
|
|
|
++ r0 = inner_radius;
|
|
|
++ r1 = outer_radius - tooth_depth / 2.0;
|
|
|
++ r2 = outer_radius + tooth_depth / 2.0;
|
|
|
++
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ /* draw front face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw front sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, -1.0);
|
|
|
++
|
|
|
++ /* draw back face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw back sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw outward faces of teeth */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ u = r2 * cos(angle + da) - r1 * cos(angle);
|
|
|
++ v = r2 * sin(angle + da) - r1 * sin(angle);
|
|
|
++ len = sqrt(u * u + v * v);
|
|
|
++ u /= len;
|
|
|
++ v /= len;
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
|
|
|
++ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glShadeModel(GL_SMOOTH);
|
|
|
++
|
|
|
++ /* draw inside radius cylinder */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glNormal3f(-cos(angle), -sin(angle), 0.0);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw(void)
|
|
|
++{
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(view_rotx, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(view_roty, 0.0, 1.0, 0.0);
|
|
|
++ glRotatef(view_rotz, 0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.0, -2.0, 0.0);
|
|
|
++ glRotatef(angle, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear1);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(3.1, -2.0, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear2);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.1, 4.2, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear3);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++struct gears {
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ Pixmap pixmap;
|
|
|
++ GLXPixmap glxpixmap;
|
|
|
++ GC gc;
|
|
|
++ int width, height;
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++/* new window size or exposure */
|
|
|
++static void
|
|
|
++reshape(struct gears *gears, int width, int height)
|
|
|
++{
|
|
|
++ gears->width = width;
|
|
|
++ gears->height = height;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++init(int width, int height)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
|
|
|
++ static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
|
|
|
++ static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
|
|
|
++ static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
|
|
|
++ GLfloat h = (GLfloat) height / (GLfloat) width;
|
|
|
++
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ /* make the gears */
|
|
|
++ gear1 = glGenLists(1);
|
|
|
++ glNewList(gear1, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
|
|
|
++ gear(1.0, 4.0, 1.0, 20, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear2 = glGenLists(1);
|
|
|
++ glNewList(gear2, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
|
|
|
++ gear(0.5, 2.0, 2.0, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear3 = glGenLists(1);
|
|
|
++ glNewList(gear3, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
|
|
|
++ gear(1.3, 2.0, 0.5, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++
|
|
|
++ glViewport(0, 0, (GLint) width, (GLint) height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -40.0);
|
|
|
++}
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window( Display *dpy, const char *name,
|
|
|
++ int x, int y, int width, int height, struct gears *gears)
|
|
|
++{
|
|
|
++ int attrib[] = { GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER, GL_FALSE,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ GLXFBConfig * fbconfig;
|
|
|
++ int num_configs;
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ gears->width = width;
|
|
|
++ gears->height = height;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ fbconfig = glXChooseFBConfig(dpy, scrnum, attrib, & num_configs);
|
|
|
++ if (fbconfig == NULL) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ visinfo = glXGetVisualFromFBConfig(dpy, fbconfig[0]);
|
|
|
++ assert(visinfo != NULL);
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ gears->win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, gears->win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, gears->win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ gears->gc = XCreateGC(dpy, gears->win, 0, NULL);
|
|
|
++
|
|
|
++ gears->pixmap = XCreatePixmap(dpy, gears->win,
|
|
|
++ width, height, visinfo->depth);
|
|
|
++ if (!gears->pixmap) {
|
|
|
++ printf("Error: XCreatePixmap failed\n");
|
|
|
++ exit(-1);
|
|
|
++ }
|
|
|
++
|
|
|
++ gears->glxpixmap = glXCreatePixmap(dpy, fbconfig[0], gears->pixmap, NULL);
|
|
|
++ if (!gears->glxpixmap) {
|
|
|
++ printf("Error: glXCreatePixmap failed\n");
|
|
|
++ exit(-1);
|
|
|
++ }
|
|
|
++
|
|
|
++ gears->ctx = glXCreateNewContext(dpy, fbconfig[0],
|
|
|
++ GLX_RGBA_TYPE, NULL, GL_TRUE);
|
|
|
++ if (!gears->ctx) {
|
|
|
++ printf("Error: glXCreateNewContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(fbconfig);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy, struct gears *gears)
|
|
|
++{
|
|
|
++ int x, y;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ while (XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ /* we'll redraw below */
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ reshape(gears, event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ view_roty += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Right) {
|
|
|
++ view_roty -= 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Up) {
|
|
|
++ view_rotx += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Down) {
|
|
|
++ view_rotx -= 5.0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ /* next frame */
|
|
|
++ angle += 2.0;
|
|
|
++
|
|
|
++ draw();
|
|
|
++ glFinish();
|
|
|
++
|
|
|
++ for (x = 0; x < gears->width; x += 100)
|
|
|
++ for (y = 0; y < gears->width; y += 100)
|
|
|
++ XCopyArea(dpy, gears->pixmap, gears->win, gears->gc,
|
|
|
++ 50, 50, 100, 100, x, y);
|
|
|
++
|
|
|
++ /* calc framerate */
|
|
|
++ {
|
|
|
++ static int t0 = -1;
|
|
|
++ static int frames = 0;
|
|
|
++ int t = current_time();
|
|
|
++
|
|
|
++ if (t0 < 0)
|
|
|
++ t0 = t;
|
|
|
++
|
|
|
++ frames++;
|
|
|
++
|
|
|
++ if (t - t0 >= 5.0) {
|
|
|
++ GLfloat seconds = t - t0;
|
|
|
++ GLfloat fps = frames / seconds;
|
|
|
++ printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
|
|
|
++ fps);
|
|
|
++ t0 = t;
|
|
|
++ frames = 0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ const char *dpyName = NULL;
|
|
|
++ GLboolean printInfo = GL_FALSE;
|
|
|
++ struct gears gears;
|
|
|
++ int i, width = 200, height = 200;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-info") == 0) {
|
|
|
++ printInfo = GL_TRUE;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n", XDisplayName(dpyName));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ make_window(dpy, "glxgears", 0, 0, width, height, &gears);
|
|
|
++ XMapWindow(dpy, gears.win);
|
|
|
++ glXMakeCurrent(dpy, gears.glxpixmap, gears.ctx);
|
|
|
++
|
|
|
++ if (printInfo) {
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
|
|
|
++ }
|
|
|
++
|
|
|
++ init(width, height);
|
|
|
++
|
|
|
++ event_loop(dpy, &gears);
|
|
|
++
|
|
|
++ glXDestroyContext(dpy, gears.ctx);
|
|
|
++ XDestroyWindow(dpy, gears.win);
|
|
|
++ glXDestroyPixmap(dpy, gears.pixmap);
|
|
|
++ XFreePixmap(dpy, gears.pixmap);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxheads.c Mesa-7.8.1.patched/progs/xdemos/glxheads.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxheads.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxheads.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,313 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * Exercise multiple GLX connections on multiple X displays.
|
|
|
++ * Direct GLX contexts are attempted first, then indirect.
|
|
|
++ * Each window will display a spinning green triangle.
|
|
|
++ *
|
|
|
++ * Copyright (C) 2000 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Each display/window/context:
|
|
|
++ */
|
|
|
++struct head {
|
|
|
++ char DisplayName[1000];
|
|
|
++ Display *Dpy;
|
|
|
++ Window Win;
|
|
|
++ GLXContext Context;
|
|
|
++ float Angle;
|
|
|
++ char Renderer[1000];
|
|
|
++ char Vendor[1000];
|
|
|
++ char Version[1000];
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++#define MAX_HEADS 20
|
|
|
++static struct head Heads[MAX_HEADS];
|
|
|
++static int NumHeads = 0;
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Error(const char *display, const char *msg)
|
|
|
++{
|
|
|
++ fprintf(stderr, "Error on display %s - %s\n", XDisplayName(display), msg);
|
|
|
++ exit(1);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static struct head *
|
|
|
++AddHead(const char *displayName)
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int width = 300, height = 300;
|
|
|
++ int xpos = 10, ypos = 10;
|
|
|
++
|
|
|
++ if (NumHeads >= MAX_HEADS)
|
|
|
++ return NULL;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(displayName);
|
|
|
++ if (!dpy) {
|
|
|
++ Error(displayName, "Unable to open display");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(dpy);
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attrib);
|
|
|
++ if (!visinfo) {
|
|
|
++ Error(displayName, "Unable to find RGB, double-buffered visual");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow(dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++ if (!win) {
|
|
|
++ Error(displayName, "Couldn't create window");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, displayName, displayName,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ ctx = glXCreateContext(dpy, visinfo, NULL, True);
|
|
|
++ if (!ctx) {
|
|
|
++ Error(displayName, "Couldn't create GLX context");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ if (!glXMakeCurrent(dpy, win, ctx)) {
|
|
|
++ Error(displayName, "glXMakeCurrent failed");
|
|
|
++ printf("glXMakeCurrent failed in Redraw()\n");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* save the info for this head */
|
|
|
++ {
|
|
|
++ struct head *h = &Heads[NumHeads];
|
|
|
++ const char * tmp;
|
|
|
++
|
|
|
++ if (strlen(displayName) + 1 > sizeof(h->DisplayName)) {
|
|
|
++ Error(displayName, "displayName string length overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->DisplayName, displayName);
|
|
|
++
|
|
|
++ h->Dpy = dpy;
|
|
|
++ h->Win = win;
|
|
|
++ h->Context = ctx;
|
|
|
++ h->Angle = 0.0;
|
|
|
++
|
|
|
++ tmp = (char *) glGetString(GL_VERSION);
|
|
|
++ if (strlen(tmp) + 1 > sizeof(h->Version)) {
|
|
|
++ Error(displayName, "GL_VERSION string length overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->Version, tmp);
|
|
|
++
|
|
|
++ tmp = (char *) glGetString(GL_VENDOR);
|
|
|
++ if (strlen(tmp) + 1 > sizeof(h->Vendor)) {
|
|
|
++ Error(displayName, "GL_VENDOR string length overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->Vendor, tmp);
|
|
|
++
|
|
|
++ tmp = (char *) glGetString(GL_RENDERER);
|
|
|
++ if (strlen(tmp) + 1 > sizeof(h->Renderer)) {
|
|
|
++ Error(displayName, "GL_RENDERER string length overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->Renderer, tmp);
|
|
|
++
|
|
|
++ NumHeads++;
|
|
|
++ return &Heads[NumHeads-1];
|
|
|
++ }
|
|
|
++
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Redraw(struct head *h)
|
|
|
++{
|
|
|
++ if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed");
|
|
|
++ printf("glXMakeCurrent failed in Redraw()\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ h->Angle += 1.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++ glClearColor(0.5, 0.5, 0.5, 1.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++
|
|
|
++ /* draw green triangle */
|
|
|
++ glColor3f(0.0, 1.0, 0.0);
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(h->Angle, 0, 0, 1);
|
|
|
++ glBegin(GL_TRIANGLES);
|
|
|
++ glVertex2f(0, 0.8);
|
|
|
++ glVertex2f(-0.8, -0.7);
|
|
|
++ glVertex2f(0.8, -0.7);
|
|
|
++ glEnd();
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glXSwapBuffers(h->Dpy, h->Win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Resize(const struct head *h, unsigned int width, unsigned int height)
|
|
|
++{
|
|
|
++ if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed in Resize()");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ glFlush();
|
|
|
++ glViewport(0, 0, width, height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++EventLoop(void)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ int i;
|
|
|
++ for (i = 0; i < NumHeads; i++) {
|
|
|
++ struct head *h = &Heads[i];
|
|
|
++ while (XPending(h->Dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(h->Dpy, &event);
|
|
|
++ if (event.xany.window == h->Win) {
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ Redraw(h);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ Resize(h, event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ return;
|
|
|
++ default:
|
|
|
++ /*no-op*/ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("window mismatch\n");
|
|
|
++ }
|
|
|
++ }
|
|
|
++ Redraw(h);
|
|
|
++ }
|
|
|
++ usleep(1);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++PrintInfo(const struct head *h)
|
|
|
++{
|
|
|
++ printf("Name: %s\n", h->DisplayName);
|
|
|
++ printf(" Display: %p\n", (void *) h->Dpy);
|
|
|
++ printf(" Window: 0x%x\n", (int) h->Win);
|
|
|
++ printf(" Context: 0x%lx\n", (long) h->Context);
|
|
|
++ printf(" GL_VERSION: %s\n", h->Version);
|
|
|
++ printf(" GL_VENDOR: %s\n", h->Vendor);
|
|
|
++ printf(" GL_RENDERER: %s\n", h->Renderer);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ int i;
|
|
|
++ if (argc == 1) {
|
|
|
++ struct head *h;
|
|
|
++ printf("glxheads: exercise multiple GLX connections (any key = exit)\n");
|
|
|
++ printf("Usage:\n");
|
|
|
++ printf(" glxheads xdisplayname ...\n");
|
|
|
++ printf("Example:\n");
|
|
|
++ printf(" glxheads :0 mars:0 venus:1\n");
|
|
|
++
|
|
|
++ h = AddHead(XDisplayName(NULL));
|
|
|
++ if (h)
|
|
|
++ PrintInfo(h);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ const char *name = argv[i];
|
|
|
++ struct head *h = AddHead(name);
|
|
|
++ if (h) {
|
|
|
++ PrintInfo(h);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ EventLoop();
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxinfo.c Mesa-7.8.1.patched/progs/xdemos/glxinfo.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxinfo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxinfo.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,1195 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * This program is a work-alike of the IRIX glxinfo program.
|
|
|
++ * Command line options:
|
|
|
++ * -t print wide table
|
|
|
++ * -v print verbose information
|
|
|
++ * -display DisplayName specify the X display to interogate
|
|
|
++ * -b only print ID of "best" visual on screen 0
|
|
|
++ * -i use indirect rendering connection only
|
|
|
++ * -l print interesting OpenGL limits (added 5 Sep 2002)
|
|
|
++ *
|
|
|
++ * Brian Paul 26 January 2000
|
|
|
++ */
|
|
|
++
|
|
|
++#define GLX_GLXEXT_PROTOTYPES
|
|
|
++
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/Xutil.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <stdlib.h>
|
|
|
++
|
|
|
++
|
|
|
++#ifndef GLX_NONE_EXT
|
|
|
++#define GLX_NONE_EXT 0x8000
|
|
|
++#endif
|
|
|
++
|
|
|
++#ifndef GLX_TRANSPARENT_RGB
|
|
|
++#define GLX_TRANSPARENT_RGB 0x8008
|
|
|
++#endif
|
|
|
++
|
|
|
++#ifndef GLX_RGBA_BIT
|
|
|
++#define GLX_RGBA_BIT 0x00000001
|
|
|
++#endif
|
|
|
++
|
|
|
++#ifndef GLX_COLOR_INDEX_BIT
|
|
|
++#define GLX_COLOR_INDEX_BIT 0x00000002
|
|
|
++#endif
|
|
|
++
|
|
|
++typedef enum
|
|
|
++{
|
|
|
++ Normal,
|
|
|
++ Wide,
|
|
|
++ Verbose
|
|
|
++} InfoMode;
|
|
|
++
|
|
|
++
|
|
|
++struct visual_attribs
|
|
|
++{
|
|
|
++ /* X visual attribs */
|
|
|
++ int id;
|
|
|
++ int klass;
|
|
|
++ int depth;
|
|
|
++ int redMask, greenMask, blueMask;
|
|
|
++ int colormapSize;
|
|
|
++ int bitsPerRGB;
|
|
|
++
|
|
|
++ /* GL visual attribs */
|
|
|
++ int supportsGL;
|
|
|
++ int transparentType;
|
|
|
++ int transparentRedValue;
|
|
|
++ int transparentGreenValue;
|
|
|
++ int transparentBlueValue;
|
|
|
++ int transparentAlphaValue;
|
|
|
++ int transparentIndexValue;
|
|
|
++ int bufferSize;
|
|
|
++ int level;
|
|
|
++ int render_type;
|
|
|
++ int doubleBuffer;
|
|
|
++ int stereo;
|
|
|
++ int auxBuffers;
|
|
|
++ int redSize, greenSize, blueSize, alphaSize;
|
|
|
++ int depthSize;
|
|
|
++ int stencilSize;
|
|
|
++ int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
|
|
|
++ int numSamples, numMultisample;
|
|
|
++ int visualCaveat;
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Print a list of extensions, with word-wrapping.
|
|
|
++ */
|
|
|
++static void
|
|
|
++print_extension_list(const char *ext)
|
|
|
++{
|
|
|
++ const char *indentString = " ";
|
|
|
++ const int indent = 4;
|
|
|
++ const int max = 79;
|
|
|
++ int width, i, j;
|
|
|
++
|
|
|
++ if (!ext || !ext[0])
|
|
|
++ return;
|
|
|
++
|
|
|
++ width = indent;
|
|
|
++ printf("%s", indentString);
|
|
|
++ i = j = 0;
|
|
|
++ while (1) {
|
|
|
++ if (ext[j] == ' ' || ext[j] == 0) {
|
|
|
++ /* found end of an extension name */
|
|
|
++ const int len = j - i;
|
|
|
++ if (width + len > max) {
|
|
|
++ /* start a new line */
|
|
|
++ printf("\n");
|
|
|
++ width = indent;
|
|
|
++ printf("%s", indentString);
|
|
|
++ }
|
|
|
++ /* print the extension name between ext[i] and ext[j] */
|
|
|
++ while (i < j) {
|
|
|
++ printf("%c", ext[i]);
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ /* either we're all done, or we'll continue with next extension */
|
|
|
++ width += len + 1;
|
|
|
++ if (ext[j] == 0) {
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ i++;
|
|
|
++ j++;
|
|
|
++ if (ext[j] == 0)
|
|
|
++ break;
|
|
|
++ printf(", ");
|
|
|
++ width += 2;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ j++;
|
|
|
++ }
|
|
|
++ printf("\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_display_info(Display *dpy)
|
|
|
++{
|
|
|
++ printf("name of display: %s\n", DisplayString(dpy));
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Print interesting limits for vertex/fragment programs.
|
|
|
++ */
|
|
|
++static void
|
|
|
++print_program_limits(GLenum target)
|
|
|
++{
|
|
|
++#if defined(GL_ARB_vertex_program) || defined(GL_ARB_fragment_program)
|
|
|
++ struct token_name {
|
|
|
++ GLenum token;
|
|
|
++ const char *name;
|
|
|
++ };
|
|
|
++ static const struct token_name common_limits[] = {
|
|
|
++ { GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_INSTRUCTIONS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_TEMPORARIES_ARB, "GL_MAX_PROGRAM_TEMPORARIES_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_PARAMETERS_ARB, "GL_MAX_PROGRAM_PARAMETERS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_ATTRIBS_ARB, "GL_MAX_PROGRAM_ATTRIBS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB" },
|
|
|
++ { (GLenum) 0, NULL }
|
|
|
++ };
|
|
|
++ static const struct token_name fragment_limits[] = {
|
|
|
++ { GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" },
|
|
|
++ { GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" },
|
|
|
++ { (GLenum) 0, NULL }
|
|
|
++ };
|
|
|
++
|
|
|
++ PFNGLGETPROGRAMIVARBPROC GetProgramivARB_func = (PFNGLGETPROGRAMIVARBPROC)
|
|
|
++ glXGetProcAddressARB((GLubyte *) "glGetProgramivARB");
|
|
|
++
|
|
|
++ GLint max[1];
|
|
|
++ int i;
|
|
|
++
|
|
|
++ if (target == GL_VERTEX_PROGRAM_ARB) {
|
|
|
++ printf(" GL_VERTEX_PROGRAM_ARB:\n");
|
|
|
++ }
|
|
|
++ else if (target == GL_FRAGMENT_PROGRAM_ARB) {
|
|
|
++ printf(" GL_FRAGMENT_PROGRAM_ARB:\n");
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ return; /* something's wrong */
|
|
|
++ }
|
|
|
++
|
|
|
++ for (i = 0; common_limits[i].token; i++) {
|
|
|
++ GetProgramivARB_func(target, common_limits[i].token, max);
|
|
|
++ if (glGetError() == GL_NO_ERROR) {
|
|
|
++ printf(" %s = %d\n", common_limits[i].name, max[0]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ if (target == GL_FRAGMENT_PROGRAM_ARB) {
|
|
|
++ for (i = 0; fragment_limits[i].token; i++) {
|
|
|
++ GetProgramivARB_func(target, fragment_limits[i].token, max);
|
|
|
++ if (glGetError() == GL_NO_ERROR) {
|
|
|
++ printf(" %s = %d\n", fragment_limits[i].name, max[0]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++#endif /* GL_ARB_vertex_program / GL_ARB_fragment_program */
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Print interesting limits for vertex/fragment shaders.
|
|
|
++ */
|
|
|
++static void
|
|
|
++print_shader_limits(GLenum target)
|
|
|
++{
|
|
|
++ struct token_name {
|
|
|
++ GLenum token;
|
|
|
++ const char *name;
|
|
|
++ };
|
|
|
++#if defined(GL_ARB_vertex_shader)
|
|
|
++ static const struct token_name vertex_limits[] = {
|
|
|
++ { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB" },
|
|
|
++ { GL_MAX_VARYING_FLOATS_ARB, "GL_MAX_VARYING_FLOATS_ARB" },
|
|
|
++ { GL_MAX_VERTEX_ATTRIBS_ARB, "GL_MAX_VERTEX_ATTRIBS_ARB" },
|
|
|
++ { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" },
|
|
|
++ { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" },
|
|
|
++ { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB" },
|
|
|
++ { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" },
|
|
|
++ { (GLenum) 0, NULL }
|
|
|
++ };
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_fragment_shader)
|
|
|
++ static const struct token_name fragment_limits[] = {
|
|
|
++ { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB" },
|
|
|
++ { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" },
|
|
|
++ { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" },
|
|
|
++ { (GLenum) 0, NULL }
|
|
|
++ };
|
|
|
++#endif
|
|
|
++ GLint max[1];
|
|
|
++ int i;
|
|
|
++
|
|
|
++#if defined(GL_ARB_vertex_shader)
|
|
|
++ if (target == GL_VERTEX_SHADER_ARB) {
|
|
|
++ printf(" GL_VERTEX_SHADER_ARB:\n");
|
|
|
++ for (i = 0; vertex_limits[i].token; i++) {
|
|
|
++ glGetIntegerv(vertex_limits[i].token, max);
|
|
|
++ if (glGetError() == GL_NO_ERROR) {
|
|
|
++ printf(" %s = %d\n", vertex_limits[i].name, max[0]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_fragment_shader)
|
|
|
++ if (target == GL_FRAGMENT_SHADER_ARB) {
|
|
|
++ printf(" GL_FRAGMENT_SHADER_ARB:\n");
|
|
|
++ for (i = 0; fragment_limits[i].token; i++) {
|
|
|
++ glGetIntegerv(fragment_limits[i].token, max);
|
|
|
++ if (glGetError() == GL_NO_ERROR) {
|
|
|
++ printf(" %s = %d\n", fragment_limits[i].name, max[0]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++#endif
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Print interesting OpenGL implementation limits.
|
|
|
++ */
|
|
|
++static void
|
|
|
++print_limits(const char *extensions)
|
|
|
++{
|
|
|
++ struct token_name {
|
|
|
++ GLuint count;
|
|
|
++ GLenum token;
|
|
|
++ const char *name;
|
|
|
++ };
|
|
|
++ static const struct token_name limits[] = {
|
|
|
++ { 1, GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH" },
|
|
|
++ { 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH" },
|
|
|
++ { 1, GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES" },
|
|
|
++ { 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "GL_MAX_COLOR_MATRIX_STACK_DEPTH" },
|
|
|
++ { 1, GL_MAX_ELEMENTS_VERTICES, "GL_MAX_ELEMENTS_VERTICES" },
|
|
|
++ { 1, GL_MAX_ELEMENTS_INDICES, "GL_MAX_ELEMENTS_INDICES" },
|
|
|
++ { 1, GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER" },
|
|
|
++ { 1, GL_MAX_LIGHTS, "GL_MAX_LIGHTS" },
|
|
|
++ { 1, GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING" },
|
|
|
++ { 1, GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH" },
|
|
|
++ { 1, GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH" },
|
|
|
++ { 1, GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE" },
|
|
|
++ { 1, GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH" },
|
|
|
++ { 1, GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH" },
|
|
|
++ { 1, GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE" },
|
|
|
++ { 1, GL_MAX_3D_TEXTURE_SIZE, "GL_MAX_3D_TEXTURE_SIZE" },
|
|
|
++ { 2, GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS" },
|
|
|
++ { 2, GL_ALIASED_LINE_WIDTH_RANGE, "GL_ALIASED_LINE_WIDTH_RANGE" },
|
|
|
++ { 2, GL_SMOOTH_LINE_WIDTH_RANGE, "GL_SMOOTH_LINE_WIDTH_RANGE" },
|
|
|
++ { 2, GL_ALIASED_POINT_SIZE_RANGE, "GL_ALIASED_POINT_SIZE_RANGE" },
|
|
|
++ { 2, GL_SMOOTH_POINT_SIZE_RANGE, "GL_SMOOTH_POINT_SIZE_RANGE" },
|
|
|
++#if defined(GL_ARB_texture_cube_map)
|
|
|
++ { 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB" },
|
|
|
++#endif
|
|
|
++#if defined(GLX_NV_texture_rectangle)
|
|
|
++ { 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV" },
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_texture_compression)
|
|
|
++ { 1, GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB" },
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_multitexture)
|
|
|
++ { 1, GL_MAX_TEXTURE_UNITS_ARB, "GL_MAX_TEXTURE_UNITS_ARB" },
|
|
|
++#endif
|
|
|
++#if defined(GL_EXT_texture_lod_bias)
|
|
|
++ { 1, GL_MAX_TEXTURE_LOD_BIAS_EXT, "GL_MAX_TEXTURE_LOD_BIAS_EXT" },
|
|
|
++#endif
|
|
|
++#if defined(GL_EXT_texture_filter_anisotropic)
|
|
|
++ { 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT" },
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_draw_buffers)
|
|
|
++ { 1, GL_MAX_DRAW_BUFFERS_ARB, "GL_MAX_DRAW_BUFFERS_ARB" },
|
|
|
++#endif
|
|
|
++ { 0, (GLenum) 0, NULL }
|
|
|
++ };
|
|
|
++ GLint i, max[2];
|
|
|
++
|
|
|
++ printf("OpenGL limits:\n");
|
|
|
++ for (i = 0; limits[i].count; i++) {
|
|
|
++ glGetIntegerv(limits[i].token, max);
|
|
|
++ if (glGetError() == GL_NO_ERROR) {
|
|
|
++ if (limits[i].count == 1)
|
|
|
++ printf(" %s = %d\n", limits[i].name, max[0]);
|
|
|
++ else /* XXX fix if we ever query something with more than 2 values */
|
|
|
++ printf(" %s = %d, %d\n", limits[i].name, max[0], max[1]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ /* these don't fit into the above mechanism, unfortunately */
|
|
|
++ glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_WIDTH, max);
|
|
|
++ glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_HEIGHT, max+1);
|
|
|
++ if (glGetError() == GL_NONE) {
|
|
|
++ printf(" GL_MAX_CONVOLUTION_WIDTH/HEIGHT = %d, %d\n", max[0], max[1]);
|
|
|
++ }
|
|
|
++
|
|
|
++#if defined(GL_ARB_vertex_program)
|
|
|
++ if (strstr(extensions, "GL_ARB_vertex_program")) {
|
|
|
++ print_program_limits(GL_VERTEX_PROGRAM_ARB);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_fragment_program)
|
|
|
++ if (strstr(extensions, "GL_ARB_fragment_program")) {
|
|
|
++ print_program_limits(GL_FRAGMENT_PROGRAM_ARB);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_vertex_shader)
|
|
|
++ if (strstr(extensions, "GL_ARB_vertex_shader")) {
|
|
|
++ print_shader_limits(GL_VERTEX_SHADER_ARB);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GL_ARB_fragment_shader)
|
|
|
++ if (strstr(extensions, "GL_ARB_fragment_shader")) {
|
|
|
++ print_shader_limits(GL_FRAGMENT_SHADER_ARB);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_screen_info(Display *dpy, int scrnum, Bool allowDirect, GLboolean limits)
|
|
|
++{
|
|
|
++ Window win;
|
|
|
++ int attribSingle[] = {
|
|
|
++ GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int attribDouble[] = {
|
|
|
++ GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ GLXContext ctx = NULL;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int width = 100, height = 100;
|
|
|
++
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ /*
|
|
|
++ * Find a basic GLX visual. We'll then create a rendering context and
|
|
|
++ * query various info strings.
|
|
|
++ */
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
|
|
|
++ if (!visinfo)
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
|
|
|
++
|
|
|
++ if (visinfo)
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect );
|
|
|
++
|
|
|
++#ifdef GLX_VERSION_1_3
|
|
|
++ /* Try glXChooseFBConfig() if glXChooseVisual didn't work.
|
|
|
++ * XXX when would that happen?
|
|
|
++ */
|
|
|
++ if (!visinfo) {
|
|
|
++ int fbAttribSingle[] = {
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER, GL_FALSE,
|
|
|
++ None };
|
|
|
++ int fbAttribDouble[] = {
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER, GL_TRUE,
|
|
|
++ None };
|
|
|
++ GLXFBConfig *configs = NULL;
|
|
|
++ int nConfigs;
|
|
|
++
|
|
|
++ configs = glXChooseFBConfig(dpy, scrnum, fbAttribSingle, &nConfigs);
|
|
|
++ if (!configs)
|
|
|
++ configs = glXChooseFBConfig(dpy, scrnum, fbAttribDouble, &nConfigs);
|
|
|
++
|
|
|
++ if (configs) {
|
|
|
++ visinfo = glXGetVisualFromFBConfig(dpy, configs[0]);
|
|
|
++ ctx = glXCreateNewContext(dpy, configs[0], GLX_RGBA_TYPE, NULL, allowDirect);
|
|
|
++ XFree(configs);
|
|
|
++ }
|
|
|
++ }
|
|
|
++#endif
|
|
|
++
|
|
|
++ if (!visinfo) {
|
|
|
++ fprintf(stderr, "Error: couldn't find RGB GLX visual or fbconfig\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!ctx) {
|
|
|
++ fprintf(stderr, "Error: glXCreateContext failed\n");
|
|
|
++ XFree(visinfo);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++ win = XCreateWindow(dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++
|
|
|
++ if (glXMakeCurrent(dpy, win, ctx)) {
|
|
|
++ const char *serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR);
|
|
|
++ const char *serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION);
|
|
|
++ const char *serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS);
|
|
|
++ const char *clientVendor = glXGetClientString(dpy, GLX_VENDOR);
|
|
|
++ const char *clientVersion = glXGetClientString(dpy, GLX_VERSION);
|
|
|
++ const char *clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS);
|
|
|
++ const char *glxExtensions = glXQueryExtensionsString(dpy, scrnum);
|
|
|
++ const char *glVendor = (const char *) glGetString(GL_VENDOR);
|
|
|
++ const char *glRenderer = (const char *) glGetString(GL_RENDERER);
|
|
|
++ const char *glVersion = (const char *) glGetString(GL_VERSION);
|
|
|
++ const char *glExtensions = (const char *) glGetString(GL_EXTENSIONS);
|
|
|
++ int glxVersionMajor;
|
|
|
++ int glxVersionMinor;
|
|
|
++ char *displayName = NULL;
|
|
|
++ char *colon = NULL, *period = NULL;
|
|
|
++
|
|
|
++ if (! glXQueryVersion( dpy, & glxVersionMajor, & glxVersionMinor )) {
|
|
|
++ fprintf(stderr, "Error: glXQueryVersion failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Strip the screen number from the display name, if present. */
|
|
|
++ if (!(displayName = (char *) malloc(strlen(DisplayString(dpy)) + 1))) {
|
|
|
++ fprintf(stderr, "Error: malloc() failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ strcpy(displayName, DisplayString(dpy));
|
|
|
++ colon = strrchr(displayName, ':');
|
|
|
++ if (colon) {
|
|
|
++ period = strchr(colon, '.');
|
|
|
++ if (period)
|
|
|
++ *period = '\0';
|
|
|
++ }
|
|
|
++ printf("display: %s screen: %d\n", displayName, scrnum);
|
|
|
++ free(displayName);
|
|
|
++ printf("direct rendering: ");
|
|
|
++ if (glXIsDirect(dpy, ctx)) {
|
|
|
++ printf("Yes\n");
|
|
|
++ } else {
|
|
|
++ if (!allowDirect) {
|
|
|
++ printf("No (-i specified)\n");
|
|
|
++ } else if (getenv("LIBGL_ALWAYS_INDIRECT")) {
|
|
|
++ printf("No (LIBGL_ALWAYS_INDIRECT set)\n");
|
|
|
++ } else {
|
|
|
++ printf("No (If you want to find out why, try setting "
|
|
|
++ "LIBGL_DEBUG=verbose)\n");
|
|
|
++ }
|
|
|
++ }
|
|
|
++ printf("server glx vendor string: %s\n", serverVendor);
|
|
|
++ printf("server glx version string: %s\n", serverVersion);
|
|
|
++ printf("server glx extensions:\n");
|
|
|
++ print_extension_list(serverExtensions);
|
|
|
++ printf("client glx vendor string: %s\n", clientVendor);
|
|
|
++ printf("client glx version string: %s\n", clientVersion);
|
|
|
++ printf("client glx extensions:\n");
|
|
|
++ print_extension_list(clientExtensions);
|
|
|
++ printf("GLX version: %u.%u\n", glxVersionMajor, glxVersionMinor);
|
|
|
++ printf("GLX extensions:\n");
|
|
|
++ print_extension_list(glxExtensions);
|
|
|
++ printf("OpenGL vendor string: %s\n", glVendor);
|
|
|
++ printf("OpenGL renderer string: %s\n", glRenderer);
|
|
|
++ printf("OpenGL version string: %s\n", glVersion);
|
|
|
++#ifdef GL_VERSION_2_0
|
|
|
++ if (glVersion[0] >= '2' && glVersion[1] == '.') {
|
|
|
++ char *v = (char *) glGetString(GL_SHADING_LANGUAGE_VERSION);
|
|
|
++ printf("OpenGL shading language version string: %s\n", v);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++
|
|
|
++ printf("OpenGL extensions:\n");
|
|
|
++ print_extension_list(glExtensions);
|
|
|
++ if (limits)
|
|
|
++ print_limits(glExtensions);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ fprintf(stderr, "Error: glXMakeCurrent failed\n");
|
|
|
++ }
|
|
|
++
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++ XFree(visinfo);
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static const char *
|
|
|
++visual_class_name(int cls)
|
|
|
++{
|
|
|
++ switch (cls) {
|
|
|
++ case StaticColor:
|
|
|
++ return "StaticColor";
|
|
|
++ case PseudoColor:
|
|
|
++ return "PseudoColor";
|
|
|
++ case StaticGray:
|
|
|
++ return "StaticGray";
|
|
|
++ case GrayScale:
|
|
|
++ return "GrayScale";
|
|
|
++ case TrueColor:
|
|
|
++ return "TrueColor";
|
|
|
++ case DirectColor:
|
|
|
++ return "DirectColor";
|
|
|
++ default:
|
|
|
++ return "";
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static const char *
|
|
|
++visual_class_abbrev(int cls)
|
|
|
++{
|
|
|
++ switch (cls) {
|
|
|
++ case StaticColor:
|
|
|
++ return "sc";
|
|
|
++ case PseudoColor:
|
|
|
++ return "pc";
|
|
|
++ case StaticGray:
|
|
|
++ return "sg";
|
|
|
++ case GrayScale:
|
|
|
++ return "gs";
|
|
|
++ case TrueColor:
|
|
|
++ return "tc";
|
|
|
++ case DirectColor:
|
|
|
++ return "dc";
|
|
|
++ default:
|
|
|
++ return "";
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++static const char *
|
|
|
++visual_render_type_name(int type)
|
|
|
++{
|
|
|
++ switch (type) {
|
|
|
++ case GLX_RGBA_BIT:
|
|
|
++ return "rgba";
|
|
|
++ case GLX_COLOR_INDEX_BIT:
|
|
|
++ return "ci";
|
|
|
++ case GLX_RGBA_BIT | GLX_COLOR_INDEX_BIT:
|
|
|
++ return "rgba|ci";
|
|
|
++ default:
|
|
|
++ return "";
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++static GLboolean
|
|
|
++get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
|
|
|
++ struct visual_attribs *attribs)
|
|
|
++{
|
|
|
++ const char *ext = glXQueryExtensionsString(dpy, vInfo->screen);
|
|
|
++ int rgba;
|
|
|
++
|
|
|
++ memset(attribs, 0, sizeof(struct visual_attribs));
|
|
|
++
|
|
|
++ attribs->id = vInfo->visualid;
|
|
|
++#if defined(__cplusplus) || defined(c_plusplus)
|
|
|
++ attribs->klass = vInfo->c_class;
|
|
|
++#else
|
|
|
++ attribs->klass = vInfo->class;
|
|
|
++#endif
|
|
|
++ attribs->depth = vInfo->depth;
|
|
|
++ attribs->redMask = vInfo->red_mask;
|
|
|
++ attribs->greenMask = vInfo->green_mask;
|
|
|
++ attribs->blueMask = vInfo->blue_mask;
|
|
|
++ attribs->colormapSize = vInfo->colormap_size;
|
|
|
++ attribs->bitsPerRGB = vInfo->bits_per_rgb;
|
|
|
++
|
|
|
++ if (glXGetConfig(dpy, vInfo, GLX_USE_GL, &attribs->supportsGL) != 0 ||
|
|
|
++ !attribs->supportsGL)
|
|
|
++ return GL_FALSE;
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_BUFFER_SIZE, &attribs->bufferSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_LEVEL, &attribs->level);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_RGBA, &rgba);
|
|
|
++ if (rgba)
|
|
|
++ attribs->render_type = GLX_RGBA_BIT;
|
|
|
++ else
|
|
|
++ attribs->render_type = GLX_COLOR_INDEX_BIT;
|
|
|
++
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_STEREO, &attribs->stereo);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_AUX_BUFFERS, &attribs->auxBuffers);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_RED_SIZE, &attribs->redSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_GREEN_SIZE, &attribs->greenSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_BLUE_SIZE, &attribs->blueSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_ALPHA_SIZE, &attribs->alphaSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_DEPTH_SIZE, &attribs->depthSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_STENCIL_SIZE, &attribs->stencilSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
|
|
|
++
|
|
|
++ /* get transparent pixel stuff */
|
|
|
++ glXGetConfig(dpy, vInfo,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
|
|
|
++ if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
|
|
|
++ }
|
|
|
++ else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* multisample attribs */
|
|
|
++#ifdef GLX_ARB_multisample
|
|
|
++ if (ext && strstr(ext, "GLX_ARB_multisample")) {
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs->numMultisample);
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_SAMPLES_ARB, &attribs->numSamples);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++ else {
|
|
|
++ attribs->numSamples = 0;
|
|
|
++ attribs->numMultisample = 0;
|
|
|
++ }
|
|
|
++
|
|
|
++#if defined(GLX_EXT_visual_rating)
|
|
|
++ if (ext && strstr(ext, "GLX_EXT_visual_rating")) {
|
|
|
++ glXGetConfig(dpy, vInfo, GLX_VISUAL_CAVEAT_EXT, &attribs->visualCaveat);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ attribs->visualCaveat = GLX_NONE_EXT;
|
|
|
++ }
|
|
|
++#else
|
|
|
++ attribs->visualCaveat = 0;
|
|
|
++#endif
|
|
|
++
|
|
|
++ return GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++#ifdef GLX_VERSION_1_3
|
|
|
++
|
|
|
++static int
|
|
|
++glx_token_to_visual_class(int visual_type)
|
|
|
++{
|
|
|
++ switch (visual_type) {
|
|
|
++ case GLX_TRUE_COLOR:
|
|
|
++ return TrueColor;
|
|
|
++ case GLX_DIRECT_COLOR:
|
|
|
++ return DirectColor;
|
|
|
++ case GLX_PSEUDO_COLOR:
|
|
|
++ return PseudoColor;
|
|
|
++ case GLX_STATIC_COLOR:
|
|
|
++ return StaticColor;
|
|
|
++ case GLX_GRAY_SCALE:
|
|
|
++ return GrayScale;
|
|
|
++ case GLX_STATIC_GRAY:
|
|
|
++ return StaticGray;
|
|
|
++ case GLX_NONE:
|
|
|
++ default:
|
|
|
++ return None;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++static GLboolean
|
|
|
++get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
|
|
|
++ struct visual_attribs *attribs)
|
|
|
++{
|
|
|
++ int visual_type;
|
|
|
++
|
|
|
++ memset(attribs, 0, sizeof(struct visual_attribs));
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_FBCONFIG_ID, &attribs->id);
|
|
|
++
|
|
|
++#if 0
|
|
|
++ attribs->depth = vInfo->depth;
|
|
|
++ attribs->redMask = vInfo->red_mask;
|
|
|
++ attribs->greenMask = vInfo->green_mask;
|
|
|
++ attribs->blueMask = vInfo->blue_mask;
|
|
|
++ attribs->colormapSize = vInfo->colormap_size;
|
|
|
++ attribs->bitsPerRGB = vInfo->bits_per_rgb;
|
|
|
++#endif
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_X_VISUAL_TYPE, &visual_type);
|
|
|
++ attribs->klass = glx_token_to_visual_class(visual_type);
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_BUFFER_SIZE, &attribs->bufferSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_LEVEL, &attribs->level);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &attribs->render_type);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_STEREO, &attribs->stereo);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_AUX_BUFFERS, &attribs->auxBuffers);
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_RED_SIZE, &attribs->redSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_GREEN_SIZE, &attribs->greenSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_BLUE_SIZE, &attribs->blueSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ALPHA_SIZE, &attribs->alphaSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_DEPTH_SIZE, &attribs->depthSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_STENCIL_SIZE, &attribs->stencilSize);
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
|
|
|
++
|
|
|
++ /* get transparent pixel stuff */
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
|
|
|
++ if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
|
|
|
++ }
|
|
|
++ else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLE_BUFFERS, &attribs->numMultisample);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLES, &attribs->numSamples);
|
|
|
++ glXGetFBConfigAttrib(dpy, fbconfig, GLX_CONFIG_CAVEAT, &attribs->visualCaveat);
|
|
|
++
|
|
|
++ return GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_visual_attribs_verbose(const struct visual_attribs *attribs)
|
|
|
++{
|
|
|
++ printf("Visual ID: %x depth=%d class=%s\n",
|
|
|
++ attribs->id, attribs->depth, visual_class_name(attribs->klass));
|
|
|
++ printf(" bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n",
|
|
|
++ attribs->bufferSize, attribs->level,
|
|
|
++ visual_render_type_name(attribs->render_type),
|
|
|
++ attribs->doubleBuffer, attribs->stereo);
|
|
|
++ printf(" rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n",
|
|
|
++ attribs->redSize, attribs->greenSize,
|
|
|
++ attribs->blueSize, attribs->alphaSize);
|
|
|
++ printf(" auxBuffers=%d depthSize=%d stencilSize=%d\n",
|
|
|
++ attribs->auxBuffers, attribs->depthSize, attribs->stencilSize);
|
|
|
++ printf(" accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n",
|
|
|
++ attribs->accumRedSize, attribs->accumGreenSize,
|
|
|
++ attribs->accumBlueSize, attribs->accumAlphaSize);
|
|
|
++ printf(" multiSample=%d multiSampleBuffers=%d\n",
|
|
|
++ attribs->numSamples, attribs->numMultisample);
|
|
|
++#ifdef GLX_EXT_visual_rating
|
|
|
++ if (attribs->visualCaveat == GLX_NONE_EXT || attribs->visualCaveat == 0)
|
|
|
++ printf(" visualCaveat=None\n");
|
|
|
++ else if (attribs->visualCaveat == GLX_SLOW_VISUAL_EXT)
|
|
|
++ printf(" visualCaveat=Slow\n");
|
|
|
++ else if (attribs->visualCaveat == GLX_NON_CONFORMANT_VISUAL_EXT)
|
|
|
++ printf(" visualCaveat=Nonconformant\n");
|
|
|
++#endif
|
|
|
++ if (attribs->transparentType == GLX_NONE) {
|
|
|
++ printf(" Opaque.\n");
|
|
|
++ }
|
|
|
++ else if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
|
|
|
++ printf(" Transparent RGB: Red=%d Green=%d Blue=%d Alpha=%d\n",attribs->transparentRedValue,attribs->transparentGreenValue,attribs->transparentBlueValue,attribs->transparentAlphaValue);
|
|
|
++ }
|
|
|
++ else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
|
|
|
++ printf(" Transparent index=%d\n",attribs->transparentIndexValue);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_visual_attribs_short_header(void)
|
|
|
++{
|
|
|
++ printf(" visual x bf lv rg d st colorbuffer ax dp st accumbuffer ms cav\n");
|
|
|
++ printf(" id dep cl sp sz l ci b ro r g b a bf th cl r g b a ns b eat\n");
|
|
|
++ printf("----------------------------------------------------------------------\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_visual_attribs_short(const struct visual_attribs *attribs)
|
|
|
++{
|
|
|
++ char *caveat = NULL;
|
|
|
++#ifdef GLX_EXT_visual_rating
|
|
|
++ if (attribs->visualCaveat == GLX_NONE_EXT || attribs->visualCaveat == 0)
|
|
|
++ caveat = "None";
|
|
|
++ else if (attribs->visualCaveat == GLX_SLOW_VISUAL_EXT)
|
|
|
++ caveat = "Slow";
|
|
|
++ else if (attribs->visualCaveat == GLX_NON_CONFORMANT_VISUAL_EXT)
|
|
|
++ caveat = "Ncon";
|
|
|
++ else
|
|
|
++ caveat = "None";
|
|
|
++#else
|
|
|
++ caveat = "None";
|
|
|
++#endif
|
|
|
++
|
|
|
++ printf("0x%02x %2d %2s %2d %2d %2d %c%c %c %c %2d %2d %2d %2d %2d %2d %2d",
|
|
|
++ attribs->id,
|
|
|
++ attribs->depth,
|
|
|
++ visual_class_abbrev(attribs->klass),
|
|
|
++ attribs->transparentType != GLX_NONE,
|
|
|
++ attribs->bufferSize,
|
|
|
++ attribs->level,
|
|
|
++ (attribs->render_type & GLX_RGBA_BIT) ? 'r' : ' ',
|
|
|
++ (attribs->render_type & GLX_COLOR_INDEX_BIT) ? 'c' : ' ',
|
|
|
++ attribs->doubleBuffer ? 'y' : '.',
|
|
|
++ attribs->stereo ? 'y' : '.',
|
|
|
++ attribs->redSize, attribs->greenSize,
|
|
|
++ attribs->blueSize, attribs->alphaSize,
|
|
|
++ attribs->auxBuffers,
|
|
|
++ attribs->depthSize,
|
|
|
++ attribs->stencilSize
|
|
|
++ );
|
|
|
++
|
|
|
++ printf(" %2d %2d %2d %2d %2d %1d %s\n",
|
|
|
++ attribs->accumRedSize, attribs->accumGreenSize,
|
|
|
++ attribs->accumBlueSize, attribs->accumAlphaSize,
|
|
|
++ attribs->numSamples, attribs->numMultisample,
|
|
|
++ caveat
|
|
|
++ );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_visual_attribs_long_header(void)
|
|
|
++{
|
|
|
++ printf("Vis Vis Visual Trans buff lev render DB ste r g b a aux dep ste accum buffers MS MS\n");
|
|
|
++ printf(" ID Depth Type parent size el type reo sz sz sz sz buf th ncl r g b a num bufs\n");
|
|
|
++ printf("----------------------------------------------------------------------------------------------------\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_visual_attribs_long(const struct visual_attribs *attribs)
|
|
|
++{
|
|
|
++ printf("0x%2x %2d %-11s %2d %2d %2d %4s %3d %3d %3d %3d %3d %3d",
|
|
|
++ attribs->id,
|
|
|
++ attribs->depth,
|
|
|
++ visual_class_name(attribs->klass),
|
|
|
++ attribs->transparentType != GLX_NONE,
|
|
|
++ attribs->bufferSize,
|
|
|
++ attribs->level,
|
|
|
++ visual_render_type_name(attribs->render_type),
|
|
|
++ attribs->doubleBuffer,
|
|
|
++ attribs->stereo,
|
|
|
++ attribs->redSize, attribs->greenSize,
|
|
|
++ attribs->blueSize, attribs->alphaSize
|
|
|
++ );
|
|
|
++
|
|
|
++ printf(" %3d %4d %2d %3d %3d %3d %3d %2d %2d\n",
|
|
|
++ attribs->auxBuffers,
|
|
|
++ attribs->depthSize,
|
|
|
++ attribs->stencilSize,
|
|
|
++ attribs->accumRedSize, attribs->accumGreenSize,
|
|
|
++ attribs->accumBlueSize, attribs->accumAlphaSize,
|
|
|
++ attribs->numSamples, attribs->numMultisample
|
|
|
++ );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++print_visual_info(Display *dpy, int scrnum, InfoMode mode)
|
|
|
++{
|
|
|
++ XVisualInfo theTemplate;
|
|
|
++ XVisualInfo *visuals;
|
|
|
++ int numVisuals, numGlxVisuals;
|
|
|
++ long mask;
|
|
|
++ int i;
|
|
|
++ struct visual_attribs attribs;
|
|
|
++
|
|
|
++ /* get list of all visuals on this screen */
|
|
|
++ theTemplate.screen = scrnum;
|
|
|
++ mask = VisualScreenMask;
|
|
|
++ visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals);
|
|
|
++
|
|
|
++ numGlxVisuals = 0;
|
|
|
++ for (i = 0; i < numVisuals; i++) {
|
|
|
++ if (get_visual_attribs(dpy, &visuals[i], &attribs))
|
|
|
++ numGlxVisuals++;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (numGlxVisuals == 0)
|
|
|
++ return;
|
|
|
++
|
|
|
++ printf("%d GLX Visuals\n", numGlxVisuals);
|
|
|
++
|
|
|
++ if (mode == Normal)
|
|
|
++ print_visual_attribs_short_header();
|
|
|
++ else if (mode == Wide)
|
|
|
++ print_visual_attribs_long_header();
|
|
|
++
|
|
|
++ for (i = 0; i < numVisuals; i++) {
|
|
|
++ if (!get_visual_attribs(dpy, &visuals[i], &attribs))
|
|
|
++ continue;
|
|
|
++
|
|
|
++ if (mode == Verbose)
|
|
|
++ print_visual_attribs_verbose(&attribs);
|
|
|
++ else if (mode == Normal)
|
|
|
++ print_visual_attribs_short(&attribs);
|
|
|
++ else if (mode == Wide)
|
|
|
++ print_visual_attribs_long(&attribs);
|
|
|
++ }
|
|
|
++ printf("\n");
|
|
|
++
|
|
|
++ XFree(visuals);
|
|
|
++}
|
|
|
++
|
|
|
++#ifdef GLX_VERSION_1_3
|
|
|
++
|
|
|
++static void
|
|
|
++print_fbconfig_info(Display *dpy, int scrnum, InfoMode mode)
|
|
|
++{
|
|
|
++ int numFBConfigs = 0;
|
|
|
++ struct visual_attribs attribs;
|
|
|
++ GLXFBConfig *fbconfigs;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ /* get list of all fbconfigs on this screen */
|
|
|
++ fbconfigs = glXGetFBConfigs(dpy, scrnum, &numFBConfigs);
|
|
|
++
|
|
|
++ if (numFBConfigs == 0) {
|
|
|
++ XFree(fbconfigs);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ printf("%d GLXFBConfigs:\n", numFBConfigs);
|
|
|
++ if (mode == Normal)
|
|
|
++ print_visual_attribs_short_header();
|
|
|
++ else if (mode == Wide)
|
|
|
++ print_visual_attribs_long_header();
|
|
|
++
|
|
|
++ for (i = 0; i < numFBConfigs; i++) {
|
|
|
++ get_fbconfig_attribs(dpy, fbconfigs[i], &attribs);
|
|
|
++
|
|
|
++ if (mode == Verbose)
|
|
|
++ print_visual_attribs_verbose(&attribs);
|
|
|
++ else if (mode == Normal)
|
|
|
++ print_visual_attribs_short(&attribs);
|
|
|
++ else if (mode == Wide)
|
|
|
++ print_visual_attribs_long(&attribs);
|
|
|
++ }
|
|
|
++ printf("\n");
|
|
|
++
|
|
|
++ XFree(fbconfigs);
|
|
|
++}
|
|
|
++
|
|
|
++#endif
|
|
|
++
|
|
|
++/*
|
|
|
++ * Stand-alone Mesa doesn't really implement the GLX protocol so it
|
|
|
++ * doesn't really know the GLX attributes associated with an X visual.
|
|
|
++ * The first time a visual is presented to Mesa's pseudo-GLX it
|
|
|
++ * attaches ancilliary buffers to it (like depth and stencil).
|
|
|
++ * But that usually only works if glXChooseVisual is used.
|
|
|
++ * This function calls glXChooseVisual() to sort of "prime the pump"
|
|
|
++ * for Mesa's GLX so that the visuals that get reported actually
|
|
|
++ * reflect what applications will see.
|
|
|
++ * This has no effect when using true GLX.
|
|
|
++ */
|
|
|
++static void
|
|
|
++mesa_hack(Display *dpy, int scrnum)
|
|
|
++{
|
|
|
++ static int attribs[] = {
|
|
|
++ GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ GLX_STENCIL_SIZE, 1,
|
|
|
++ GLX_ACCUM_RED_SIZE, 1,
|
|
|
++ GLX_ACCUM_GREEN_SIZE, 1,
|
|
|
++ GLX_ACCUM_BLUE_SIZE, 1,
|
|
|
++ GLX_ACCUM_ALPHA_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None
|
|
|
++ };
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attribs);
|
|
|
++ if (visinfo)
|
|
|
++ XFree(visinfo);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Examine all visuals to find the so-called best one.
|
|
|
++ * We prefer deepest RGBA buffer with depth, stencil and accum
|
|
|
++ * that has no caveats.
|
|
|
++ */
|
|
|
++static int
|
|
|
++find_best_visual(Display *dpy, int scrnum)
|
|
|
++{
|
|
|
++ XVisualInfo theTemplate;
|
|
|
++ XVisualInfo *visuals;
|
|
|
++ int numVisuals;
|
|
|
++ long mask;
|
|
|
++ int i;
|
|
|
++ struct visual_attribs bestVis;
|
|
|
++
|
|
|
++ /* get list of all visuals on this screen */
|
|
|
++ theTemplate.screen = scrnum;
|
|
|
++ mask = VisualScreenMask;
|
|
|
++ visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals);
|
|
|
++
|
|
|
++ /* init bestVis with first visual info */
|
|
|
++ get_visual_attribs(dpy, &visuals[0], &bestVis);
|
|
|
++
|
|
|
++ /* try to find a "better" visual */
|
|
|
++ for (i = 1; i < numVisuals; i++) {
|
|
|
++ struct visual_attribs vis;
|
|
|
++
|
|
|
++ get_visual_attribs(dpy, &visuals[i], &vis);
|
|
|
++
|
|
|
++ /* always skip visuals with caveats */
|
|
|
++ if (vis.visualCaveat != GLX_NONE_EXT)
|
|
|
++ continue;
|
|
|
++
|
|
|
++ /* see if this vis is better than bestVis */
|
|
|
++ if ((!bestVis.supportsGL && vis.supportsGL) ||
|
|
|
++ (bestVis.visualCaveat != GLX_NONE_EXT) ||
|
|
|
++ (!(bestVis.render_type & GLX_RGBA_BIT) && (vis.render_type & GLX_RGBA_BIT)) ||
|
|
|
++ (!bestVis.doubleBuffer && vis.doubleBuffer) ||
|
|
|
++ (bestVis.redSize < vis.redSize) ||
|
|
|
++ (bestVis.greenSize < vis.greenSize) ||
|
|
|
++ (bestVis.blueSize < vis.blueSize) ||
|
|
|
++ (bestVis.alphaSize < vis.alphaSize) ||
|
|
|
++ (bestVis.depthSize < vis.depthSize) ||
|
|
|
++ (bestVis.stencilSize < vis.stencilSize) ||
|
|
|
++ (bestVis.accumRedSize < vis.accumRedSize)) {
|
|
|
++ /* found a better visual */
|
|
|
++ bestVis = vis;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(visuals);
|
|
|
++
|
|
|
++ return bestVis.id;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++usage(void)
|
|
|
++{
|
|
|
++ printf("Usage: glxinfo [-v] [-t] [-h] [-i] [-b] [-display <dname>]\n");
|
|
|
++ printf("\t-v: Print visuals info in verbose form.\n");
|
|
|
++ printf("\t-t: Print verbose table.\n");
|
|
|
++ printf("\t-display <dname>: Print GLX visuals on specified server.\n");
|
|
|
++ printf("\t-h: This information.\n");
|
|
|
++ printf("\t-i: Force an indirect rendering context.\n");
|
|
|
++ printf("\t-b: Find the 'best' visual and print its number.\n");
|
|
|
++ printf("\t-l: Print interesting OpenGL limits.\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ char *displayName = NULL;
|
|
|
++ Display *dpy;
|
|
|
++ int numScreens, scrnum;
|
|
|
++ InfoMode mode = Normal;
|
|
|
++ GLboolean findBest = GL_FALSE;
|
|
|
++ GLboolean limits = GL_FALSE;
|
|
|
++ Bool allowDirect = True;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
|
|
|
++ displayName = argv[i + 1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-t") == 0) {
|
|
|
++ mode = Wide;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-v") == 0) {
|
|
|
++ mode = Verbose;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-b") == 0) {
|
|
|
++ findBest = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-i") == 0) {
|
|
|
++ allowDirect = False;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-l") == 0) {
|
|
|
++ limits = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-h") == 0) {
|
|
|
++ usage();
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Unknown option `%s'\n", argv[i]);
|
|
|
++ usage();
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(displayName);
|
|
|
++ if (!dpy) {
|
|
|
++ fprintf(stderr, "Error: unable to open display %s\n", XDisplayName(displayName));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (findBest) {
|
|
|
++ int b;
|
|
|
++ mesa_hack(dpy, 0);
|
|
|
++ b = find_best_visual(dpy, 0);
|
|
|
++ printf("%d\n", b);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ numScreens = ScreenCount(dpy);
|
|
|
++ print_display_info(dpy);
|
|
|
++ for (scrnum = 0; scrnum < numScreens; scrnum++) {
|
|
|
++ mesa_hack(dpy, scrnum);
|
|
|
++ print_screen_info(dpy, scrnum, allowDirect, limits);
|
|
|
++ printf("\n");
|
|
|
++ print_visual_info(dpy, scrnum, mode);
|
|
|
++#ifdef GLX_VERSION_1_3
|
|
|
++ print_fbconfig_info(dpy, scrnum, mode);
|
|
|
++#endif
|
|
|
++ if (scrnum + 1 < numScreens)
|
|
|
++ printf("\n\n");
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxpbdemo.c Mesa-7.8.1.patched/progs/xdemos/glxpbdemo.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxpbdemo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxpbdemo.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,431 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * This program demonstrates how to do "off-screen" rendering using
|
|
|
++ * the GLX pixel buffer extension.
|
|
|
++ *
|
|
|
++ * Written by Brian Paul for the "OpenGL and Window System Integration"
|
|
|
++ * course presented at SIGGRAPH '97. Updated on 5 October 2002.
|
|
|
++ *
|
|
|
++ * Updated on 31 January 2004 to use native GLX by
|
|
|
++ * Andrew P. Lentvorski, Jr. <bsder@allcaps.org>
|
|
|
++ *
|
|
|
++ * Usage:
|
|
|
++ * glxpbdemo width height imgfile
|
|
|
++ * Where:
|
|
|
++ * width is the width, in pixels, of the image to generate.
|
|
|
++ * height is the height, in pixels, of the image to generate.
|
|
|
++ * imgfile is the name of the PPM image file to write.
|
|
|
++ *
|
|
|
++ *
|
|
|
++ * This demo draws 3-D boxes with random orientation.
|
|
|
++ *
|
|
|
++ * On machines such as the SGI Indigo you may have to reconfigure your
|
|
|
++ * display/X server to enable pbuffers. Look in the /usr/gfx/ucode/MGRAS/vof/
|
|
|
++ * directory for display configurations with the _pbuf suffix. Use
|
|
|
++ * setmon -x <vof> to configure your X server and display for pbuffers.
|
|
|
++ *
|
|
|
++ * O2 systems seem to support pbuffers well.
|
|
|
++ *
|
|
|
++ */
|
|
|
++
|
|
|
++#include <string.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++/* Some ugly global vars */
|
|
|
++static GLXFBConfig gFBconfig = 0;
|
|
|
++static Display *gDpy = NULL;
|
|
|
++static int gScreen = 0;
|
|
|
++static GLXPbuffer gPBuffer = 0;
|
|
|
++static int gWidth, gHeight;
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Test for appropriate version of GLX to run this program
|
|
|
++ * Input: dpy - the X display
|
|
|
++ * screen - screen number
|
|
|
++ * Return: 0 = GLX not available.
|
|
|
++ * 1 = GLX available.
|
|
|
++ */
|
|
|
++static int
|
|
|
++RuntimeQueryGLXVersion(Display *dpy, int screen)
|
|
|
++{
|
|
|
++#if defined(GLX_VERSION_1_3) || defined(GLX_VERSION_1_4)
|
|
|
++ char *glxversion;
|
|
|
++
|
|
|
++ glxversion = (char *) glXGetClientString(dpy, GLX_VERSION);
|
|
|
++ if (!(strstr(glxversion, "1.3") || strstr(glxversion, "1.4")))
|
|
|
++ return 0;
|
|
|
++
|
|
|
++ glxversion = (char *) glXQueryServerString(dpy, screen, GLX_VERSION);
|
|
|
++ if (!(strstr(glxversion, "1.3") || strstr(glxversion, "1.4")))
|
|
|
++ return 0;
|
|
|
++
|
|
|
++ return 1;
|
|
|
++#else
|
|
|
++ return 0;
|
|
|
++#endif
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create the pbuffer and return a GLXPbuffer handle.
|
|
|
++ */
|
|
|
++static GLXPbuffer
|
|
|
++MakePbuffer( Display *dpy, int screen, int width, int height )
|
|
|
++{
|
|
|
++ GLXFBConfig *fbConfigs;
|
|
|
++ GLXFBConfig chosenFBConfig;
|
|
|
++ GLXPbuffer pBuffer = None;
|
|
|
++
|
|
|
++ int nConfigs;
|
|
|
++ int fbconfigid;
|
|
|
++
|
|
|
++ int fbAttribs[] = {
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT | GLX_PBUFFER_BIT,
|
|
|
++ None
|
|
|
++ };
|
|
|
++
|
|
|
++ int pbAttribs[] = {
|
|
|
++ GLX_PBUFFER_WIDTH, 0,
|
|
|
++ GLX_PBUFFER_HEIGHT, 0,
|
|
|
++ GLX_LARGEST_PBUFFER, False,
|
|
|
++ GLX_PRESERVED_CONTENTS, False,
|
|
|
++ None
|
|
|
++ };
|
|
|
++
|
|
|
++ pbAttribs[1] = width;
|
|
|
++ pbAttribs[3] = height;
|
|
|
++
|
|
|
++ fbConfigs = glXChooseFBConfig(dpy, screen, fbAttribs, &nConfigs);
|
|
|
++
|
|
|
++ if (0 == nConfigs || !fbConfigs) {
|
|
|
++ printf("Error: glxChooseFBConfig failed\n");
|
|
|
++ XFree(fbConfigs);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ chosenFBConfig = fbConfigs[0];
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(dpy, chosenFBConfig, GLX_FBCONFIG_ID, &fbconfigid);
|
|
|
++ printf("Chose 0x%x as fbconfigid\n", fbconfigid);
|
|
|
++
|
|
|
++ /* Create the pbuffer using first fbConfig in the list that works. */
|
|
|
++ pBuffer = glXCreatePbuffer(dpy, chosenFBConfig, pbAttribs);
|
|
|
++
|
|
|
++ if (pBuffer) {
|
|
|
++ gFBconfig = chosenFBConfig;
|
|
|
++ gWidth = width;
|
|
|
++ gHeight = height;
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(fbConfigs);
|
|
|
++
|
|
|
++ return pBuffer;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Do all the X / GLX setup stuff.
|
|
|
++ */
|
|
|
++static int
|
|
|
++Setup(int width, int height)
|
|
|
++{
|
|
|
++#if defined(GLX_VERSION_1_3) || defined(GLX_VERSION_1_4)
|
|
|
++ GLXContext glCtx;
|
|
|
++
|
|
|
++ /* Open the X display */
|
|
|
++ gDpy = XOpenDisplay(NULL);
|
|
|
++ if (!gDpy) {
|
|
|
++ printf("Error: couldn't open default X display.\n");
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Get default screen */
|
|
|
++ gScreen = DefaultScreen(gDpy);
|
|
|
++
|
|
|
++ /* Test that GLX is available */
|
|
|
++ if (!RuntimeQueryGLXVersion(gDpy, gScreen)) {
|
|
|
++ printf("Error: GLX 1.3 or 1.4 not available\n");
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Create Pbuffer */
|
|
|
++ gPBuffer = MakePbuffer( gDpy, gScreen, width, height );
|
|
|
++ if (gPBuffer==None) {
|
|
|
++ printf("Error: couldn't create pbuffer\n");
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Create GLX context */
|
|
|
++ glCtx = glXCreateNewContext(gDpy, gFBconfig, GLX_RGBA_TYPE, NULL, True);
|
|
|
++ if (glCtx) {
|
|
|
++ if (!glXIsDirect(gDpy, glCtx)) {
|
|
|
++ printf("Warning: using indirect GLXContext\n");
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Error: Couldn't create GLXContext\n");
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Bind context to pbuffer */
|
|
|
++ if (!glXMakeCurrent(gDpy, gPBuffer, glCtx)) {
|
|
|
++ printf("Error: glXMakeCurrent failed\n");
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ return 1; /* Success!! */
|
|
|
++#else
|
|
|
++ printf("Error: GLX version 1.3 or 1.4 not available at compile time\n");
|
|
|
++ return 0;
|
|
|
++#endif
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/* One-time GL setup */
|
|
|
++static void
|
|
|
++InitGL(void)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = {0.0, 0.0, 10.0, 0.0};
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++
|
|
|
++ glViewport(0, 0, gWidth, gHeight);
|
|
|
++ glMatrixMode( GL_PROJECTION );
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 );
|
|
|
++ glMatrixMode( GL_MODELVIEW );
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef( 0.0, 0.0, -15.0 );
|
|
|
++
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* Return random float in [0,1] */
|
|
|
++static float
|
|
|
++Random(void)
|
|
|
++{
|
|
|
++ int i = rand();
|
|
|
++ return (float) (i % 1000) / 1000.0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++RandomColor(void)
|
|
|
++{
|
|
|
++ GLfloat c[4];
|
|
|
++ c[0] = Random();
|
|
|
++ c[1] = Random();
|
|
|
++ c[2] = Random();
|
|
|
++ c[3] = 1.0;
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, c);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* This function borrowed from Mark Kilgard's GLUT */
|
|
|
++static void
|
|
|
++drawBox(GLfloat x0, GLfloat x1, GLfloat y0, GLfloat y1,
|
|
|
++ GLfloat z0, GLfloat z1, GLenum type)
|
|
|
++{
|
|
|
++ static GLfloat n[6][3] =
|
|
|
++ {
|
|
|
++ {-1.0, 0.0, 0.0},
|
|
|
++ {0.0, 1.0, 0.0},
|
|
|
++ {1.0, 0.0, 0.0},
|
|
|
++ {0.0, -1.0, 0.0},
|
|
|
++ {0.0, 0.0, 1.0},
|
|
|
++ {0.0, 0.0, -1.0}
|
|
|
++ };
|
|
|
++ static GLint faces[6][4] =
|
|
|
++ {
|
|
|
++ {0, 1, 2, 3},
|
|
|
++ {3, 2, 6, 7},
|
|
|
++ {7, 6, 5, 4},
|
|
|
++ {4, 5, 1, 0},
|
|
|
++ {5, 6, 2, 1},
|
|
|
++ {7, 4, 0, 3}
|
|
|
++ };
|
|
|
++ GLfloat v[8][3], tmp;
|
|
|
++ GLint i;
|
|
|
++
|
|
|
++ if (x0 > x1) {
|
|
|
++ tmp = x0;
|
|
|
++ x0 = x1;
|
|
|
++ x1 = tmp;
|
|
|
++ }
|
|
|
++ if (y0 > y1) {
|
|
|
++ tmp = y0;
|
|
|
++ y0 = y1;
|
|
|
++ y1 = tmp;
|
|
|
++ }
|
|
|
++ if (z0 > z1) {
|
|
|
++ tmp = z0;
|
|
|
++ z0 = z1;
|
|
|
++ z1 = tmp;
|
|
|
++ }
|
|
|
++ v[0][0] = v[1][0] = v[2][0] = v[3][0] = x0;
|
|
|
++ v[4][0] = v[5][0] = v[6][0] = v[7][0] = x1;
|
|
|
++ v[0][1] = v[1][1] = v[4][1] = v[5][1] = y0;
|
|
|
++ v[2][1] = v[3][1] = v[6][1] = v[7][1] = y1;
|
|
|
++ v[0][2] = v[3][2] = v[4][2] = v[7][2] = z0;
|
|
|
++ v[1][2] = v[2][2] = v[5][2] = v[6][2] = z1;
|
|
|
++
|
|
|
++ for (i = 0; i < 6; i++) {
|
|
|
++ glBegin(type);
|
|
|
++ glNormal3fv(&n[i][0]);
|
|
|
++ glVertex3fv(&v[faces[i][0]][0]);
|
|
|
++ glVertex3fv(&v[faces[i][1]][0]);
|
|
|
++ glVertex3fv(&v[faces[i][2]][0]);
|
|
|
++ glVertex3fv(&v[faces[i][3]][0]);
|
|
|
++ glEnd();
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/* Render a scene */
|
|
|
++static void
|
|
|
++Render(void)
|
|
|
++{
|
|
|
++ int NumBoxes = 100;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ InitGL();
|
|
|
++ glClearColor(0.2, 0.2, 0.9, 0.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ for (i=0;i<NumBoxes;i++) {
|
|
|
++ float tx = -2.0 + 4.0 * Random();
|
|
|
++ float ty = -2.0 + 4.0 * Random();
|
|
|
++ float tz = 4.0 - 16.0 * Random();
|
|
|
++ float sx = 0.1 + Random() * 0.4;
|
|
|
++ float sy = 0.1 + Random() * 0.4;
|
|
|
++ float sz = 0.1 + Random() * 0.4;
|
|
|
++ float rx = Random();
|
|
|
++ float ry = Random();
|
|
|
++ float rz = Random();
|
|
|
++ float ra = Random() * 360.0;
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(tx, ty, tz);
|
|
|
++ glRotatef(ra, rx, ry, rz);
|
|
|
++ glScalef(sx, sy, sz);
|
|
|
++ RandomColor();
|
|
|
++ drawBox(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0, GL_POLYGON);
|
|
|
++ glPopMatrix();
|
|
|
++ }
|
|
|
++
|
|
|
++ glFinish();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++WriteFile(const char *filename)
|
|
|
++{
|
|
|
++ FILE *f;
|
|
|
++ GLubyte *image;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ image = malloc(gWidth * gHeight * 3 * sizeof(GLubyte));
|
|
|
++ if (!image) {
|
|
|
++ printf("Error: couldn't allocate image buffer\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
|
++ glReadPixels(0, 0, gWidth, gHeight, GL_RGB, GL_UNSIGNED_BYTE, image);
|
|
|
++
|
|
|
++ f = fopen(filename, "w");
|
|
|
++ if (!f) {
|
|
|
++ printf("Couldn't open image file: %s\n", filename);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ fprintf(f,"P6\n");
|
|
|
++ fprintf(f,"# ppm-file created by %s\n", "trdemo2");
|
|
|
++ fprintf(f,"%i %i\n", gWidth, gHeight);
|
|
|
++ fprintf(f,"255\n");
|
|
|
++ fclose(f);
|
|
|
++ f = fopen(filename, "ab"); /* now append binary data */
|
|
|
++ if (!f) {
|
|
|
++ printf("Couldn't append to image file: %s\n", filename);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ for (i=0;i<gHeight;i++) {
|
|
|
++ GLubyte *rowPtr;
|
|
|
++ /* Remember, OpenGL images are bottom to top. Have to reverse. */
|
|
|
++ rowPtr = image + (gHeight-1-i) * gWidth*3;
|
|
|
++ fwrite(rowPtr, 1, gWidth*3, f);
|
|
|
++ }
|
|
|
++
|
|
|
++ fclose(f);
|
|
|
++ free(image);
|
|
|
++
|
|
|
++ printf("Wrote %d by %d image file: %s\n", gWidth, gHeight, filename);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Print message describing command line parameters.
|
|
|
++ */
|
|
|
++static void
|
|
|
++Usage(const char *appName)
|
|
|
++{
|
|
|
++ printf("Usage:\n");
|
|
|
++ printf(" %s width height imgfile\n", appName);
|
|
|
++ printf("Where imgfile is a ppm file\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ if (argc!=4) {
|
|
|
++ Usage(argv[0]);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ int width = atoi(argv[1]);
|
|
|
++ int height = atoi(argv[2]);
|
|
|
++ char *fileName = argv[3];
|
|
|
++ if (width<=0) {
|
|
|
++ printf("Error: width parameter must be at least 1.\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++ if (height<=0) {
|
|
|
++ printf("Error: height parameter must be at least 1.\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++ if (!Setup(width, height)) {
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++
|
|
|
++ printf("Setup completed\n");
|
|
|
++ Render();
|
|
|
++ printf("Render completed.\n");
|
|
|
++ WriteFile(fileName);
|
|
|
++ printf("File write completed.\n");
|
|
|
++
|
|
|
++ glXDestroyPbuffer( gDpy, gPBuffer );
|
|
|
++ }
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxpixmap.c Mesa-7.8.1.patched/progs/xdemos/glxpixmap.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxpixmap.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxpixmap.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,187 @@
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * A demonstration of using the GLXPixmap functions. This program is in
|
|
|
++ * the public domain.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#define GLX_GLXEXT_PROTOTYPES
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++
|
|
|
++
|
|
|
++static GLXContext ctx;
|
|
|
++static XVisualInfo *visinfo;
|
|
|
++static GC gc;
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static Window make_rgb_window( Display *dpy,
|
|
|
++ unsigned int width, unsigned int height )
|
|
|
++{
|
|
|
++ const int sbAttrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ None };
|
|
|
++ const int dbAttrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, (int *) sbAttrib );
|
|
|
++ if (!visinfo) {
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, (int *) dbAttrib );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ /* TODO: share root colormap if possible */
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* make an X GC so we can do XCopyArea later */
|
|
|
++ gc = XCreateGC( dpy, win, 0, NULL );
|
|
|
++
|
|
|
++ /* need indirect context */
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, False );
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(-1);
|
|
|
++ }
|
|
|
++
|
|
|
++ printf("Direct rendering: %s\n", glXIsDirect(dpy, ctx) ? "Yes" : "No");
|
|
|
++
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static GLXPixmap make_pixmap( Display *dpy, Window win,
|
|
|
++ unsigned int width, unsigned int height,
|
|
|
++ Pixmap *pixmap)
|
|
|
++{
|
|
|
++ Pixmap pm;
|
|
|
++ GLXPixmap glxpm;
|
|
|
++ XWindowAttributes attr;
|
|
|
++
|
|
|
++ pm = XCreatePixmap( dpy, win, width, height, visinfo->depth );
|
|
|
++ if (!pm) {
|
|
|
++ printf("Error: XCreatePixmap failed\n");
|
|
|
++ exit(-1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XGetWindowAttributes( dpy, win, &attr );
|
|
|
++
|
|
|
++ /*
|
|
|
++ * IMPORTANT:
|
|
|
++ * Use the glXCreateGLXPixmapMESA funtion when using Mesa because
|
|
|
++ * Mesa needs to know the colormap associated with a pixmap in order
|
|
|
++ * to render correctly. This is because Mesa allows RGB rendering
|
|
|
++ * into any kind of visual, not just TrueColor or DirectColor.
|
|
|
++ */
|
|
|
++#ifdef GLX_MESA_pixmap_colormap
|
|
|
++ if (strstr(glXQueryExtensionsString(dpy, 0), "GLX_MESA_pixmap_colormap")) {
|
|
|
++ /* stand-alone Mesa, specify the colormap */
|
|
|
++ glxpm = glXCreateGLXPixmapMESA( dpy, visinfo, pm, attr.colormap );
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glxpm = glXCreateGLXPixmap( dpy, visinfo, pm );
|
|
|
++ }
|
|
|
++#else
|
|
|
++ /* This will work with Mesa too if the visual is TrueColor or DirectColor */
|
|
|
++ glxpm = glXCreateGLXPixmap( dpy, visinfo, pm );
|
|
|
++#endif
|
|
|
++
|
|
|
++ if (!glxpm) {
|
|
|
++ printf("Error: GLXCreateGLXPixmap failed\n");
|
|
|
++ exit(-1);
|
|
|
++ }
|
|
|
++
|
|
|
++ *pixmap = pm;
|
|
|
++
|
|
|
++ return glxpm;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void event_loop( Display *dpy, GLXPixmap pm )
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ XNextEvent( dpy, &event );
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ printf("Redraw\n");
|
|
|
++ /* copy the image from GLXPixmap to window */
|
|
|
++ XCopyArea( dpy, pm, event.xany.window, /* src, dest */
|
|
|
++ gc, 0, 0, 300, 300, /* gc, src pos, size */
|
|
|
++ 0, 0 ); /* dest pos */
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ /* nothing */
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int main( int argc, char *argv[] )
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ Pixmap pm;
|
|
|
++ GLXPixmap glxpm;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++
|
|
|
++ win = make_rgb_window( dpy, 300, 300 );
|
|
|
++ glxpm = make_pixmap( dpy, win, 300, 300, &pm );
|
|
|
++
|
|
|
++ glXMakeCurrent( dpy, glxpm, ctx );
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++
|
|
|
++ /* Render an image into the pixmap */
|
|
|
++ glShadeModel( GL_FLAT );
|
|
|
++ glClearColor( 0.5, 0.5, 0.5, 1.0 );
|
|
|
++ glClear( GL_COLOR_BUFFER_BIT );
|
|
|
++ glViewport( 0, 0, 300, 300 );
|
|
|
++ glOrtho( -1.0, 1.0, -1.0, 1.0, -1.0, 1.0 );
|
|
|
++ glColor3f( 0.0, 1.0, 1.0 );
|
|
|
++ glRectf( -0.75, -0.75, 0.75, 0.75 );
|
|
|
++ glFlush();
|
|
|
++ glXWaitGL();
|
|
|
++
|
|
|
++ XMapWindow( dpy, win );
|
|
|
++
|
|
|
++ event_loop( dpy, pm );
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxsnoop.c Mesa-7.8.1.patched/progs/xdemos/glxsnoop.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxsnoop.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxsnoop.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,377 @@
|
|
|
++/**
|
|
|
++ * Display/snoop the z/stencil/back/front buffers of another app's window.
|
|
|
++ * Also, an example of the need for shared ancillary renderbuffers.
|
|
|
++ *
|
|
|
++ * Hint: use 'xwininfo' to get a window's ID.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * 11 Oct 2007
|
|
|
++ */
|
|
|
++
|
|
|
++#define GL_GLEXT_PROTOTYPES
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++
|
|
|
++
|
|
|
++#define Z_BUFFER 1
|
|
|
++#define STENCIL_BUFFER 2
|
|
|
++#define BACK_BUFFER 3
|
|
|
++#define FRONT_BUFFER 4
|
|
|
++
|
|
|
++
|
|
|
++static int Buffer = BACK_BUFFER;
|
|
|
++static int WindowID = 0;
|
|
|
++static const char *DisplayName = NULL;
|
|
|
++static GLXContext Context = 0;
|
|
|
++static int Width, Height;
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Grab the z/stencil/back/front image from the srcWin and display it
|
|
|
++ * (possibly converted to grayscale) in the dstWin.
|
|
|
++ */
|
|
|
++static void
|
|
|
++redraw(Display *dpy, Window srcWin, Window dstWin )
|
|
|
++{
|
|
|
++ GLubyte *image = malloc(Width * Height * 4);
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, srcWin, Context);
|
|
|
++ glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
|
++ if (Buffer == BACK_BUFFER) {
|
|
|
++ glReadBuffer(GL_BACK);
|
|
|
++ glReadPixels(0, 0, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, image);
|
|
|
++ }
|
|
|
++ else if (Buffer == FRONT_BUFFER) {
|
|
|
++ glReadBuffer(GL_FRONT);
|
|
|
++ glReadPixels(0, 0, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, image);
|
|
|
++ }
|
|
|
++ else if (Buffer == Z_BUFFER) {
|
|
|
++ GLfloat *z = malloc(Width * Height * sizeof(GLfloat));
|
|
|
++ int i;
|
|
|
++ glReadPixels(0, 0, Width, Height, GL_DEPTH_COMPONENT, GL_FLOAT, z);
|
|
|
++ for (i = 0; i < Width * Height; i++) {
|
|
|
++ image[i*4+0] =
|
|
|
++ image[i*4+1] =
|
|
|
++ image[i*4+2] = (GLint) (255.0 * z[i]);
|
|
|
++ image[i*4+3] = 255;
|
|
|
++ }
|
|
|
++ free(z);
|
|
|
++ }
|
|
|
++ else if (Buffer == STENCIL_BUFFER) {
|
|
|
++ GLubyte *sten = malloc(Width * Height * sizeof(GLubyte));
|
|
|
++ int i, min = 100, max = -1;
|
|
|
++ float step;
|
|
|
++ int sz;
|
|
|
++ glGetIntegerv(GL_STENCIL_BITS, &sz);
|
|
|
++ glReadPixels(0, 0, Width, Height,
|
|
|
++ GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, sten);
|
|
|
++ /* find min/max for converting stencil to grayscale */
|
|
|
++ for (i = 0; i < Width * Height; i++) {
|
|
|
++ if (sten[i] < min)
|
|
|
++ min = sten[i];
|
|
|
++ if (sten[i] > max)
|
|
|
++ max = sten[i];
|
|
|
++ }
|
|
|
++ if (min == max)
|
|
|
++ step = 0;
|
|
|
++ else
|
|
|
++ step = 255.0 / (float) (max - min);
|
|
|
++ for (i = 0; i < Width * Height; i++) {
|
|
|
++ image[i*4+0] =
|
|
|
++ image[i*4+1] =
|
|
|
++ image[i*4+2] = (GLint) ((sten[i] - min) * step);
|
|
|
++ image[i*4+3] = 255;
|
|
|
++ }
|
|
|
++ free(sten);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, dstWin, Context);
|
|
|
++ glWindowPos2iARB(0, 0);
|
|
|
++ glDrawBuffer(GL_FRONT);
|
|
|
++ glDrawPixels(Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, image);
|
|
|
++ glFlush();
|
|
|
++
|
|
|
++ free(image);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++set_window_title(Display *dpy, Window win, const char *title)
|
|
|
++{
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.flags = 0;
|
|
|
++ XSetStandardProperties(dpy, win, title, title,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static Window
|
|
|
++make_gl_window(Display *dpy, XVisualInfo *visinfo, int width, int height)
|
|
|
++{
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ int x = 0, y = 0;
|
|
|
++ char *name = NULL;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, x, y, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++update_window_title(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ char title[1000], *buf;
|
|
|
++
|
|
|
++ switch (Buffer) {
|
|
|
++ case Z_BUFFER:
|
|
|
++ buf = "Z";
|
|
|
++ break;
|
|
|
++ case STENCIL_BUFFER:
|
|
|
++ buf = "Stencil";
|
|
|
++ break;
|
|
|
++ case BACK_BUFFER:
|
|
|
++ buf = "Back";
|
|
|
++ break;
|
|
|
++ case FRONT_BUFFER:
|
|
|
++ buf = "Front";
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ buf = "";
|
|
|
++ }
|
|
|
++
|
|
|
++ sprintf(title, "glxsnoop window 0x%x (%s buffer)", (int) WindowID, buf);
|
|
|
++
|
|
|
++ set_window_title(dpy, win, title);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++keypress(Display *dpy, Window win, char key)
|
|
|
++{
|
|
|
++ switch (key) {
|
|
|
++ case 27:
|
|
|
++ /* escape */
|
|
|
++ exit(0);
|
|
|
++ break;
|
|
|
++ case 's':
|
|
|
++ Buffer = STENCIL_BUFFER;
|
|
|
++ break;
|
|
|
++ case 'z':
|
|
|
++ Buffer = Z_BUFFER;
|
|
|
++ break;
|
|
|
++ case 'f':
|
|
|
++ Buffer = FRONT_BUFFER;
|
|
|
++ break;
|
|
|
++ case 'b':
|
|
|
++ Buffer = BACK_BUFFER;
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ update_window_title(dpy, win);
|
|
|
++ redraw(dpy, WindowID, win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ XNextEvent( dpy, &event );
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ redraw(dpy, WindowID, win);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ /*resize( event.xconfigure.width, event.xconfigure.height );*/
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ keypress(dpy, win, buffer[0]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ default:
|
|
|
++ /* nothing */
|
|
|
++ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static VisualID
|
|
|
++get_window_visualid(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ XWindowAttributes attr;
|
|
|
++
|
|
|
++ if (XGetWindowAttributes(dpy, win, &attr)) {
|
|
|
++ return attr.visual->visualid;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++get_window_size(Display *dpy, Window win, int *w, int *h)
|
|
|
++{
|
|
|
++ XWindowAttributes attr;
|
|
|
++
|
|
|
++ if (XGetWindowAttributes(dpy, win, &attr)) {
|
|
|
++ *w = attr.width;
|
|
|
++ *h = attr.height;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ *w = *h = 0;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static XVisualInfo *
|
|
|
++visualid_to_visualinfo(Display *dpy, VisualID vid)
|
|
|
++{
|
|
|
++ XVisualInfo *vinfo, templ;
|
|
|
++ long mask;
|
|
|
++ int n;
|
|
|
++
|
|
|
++ templ.visualid = vid;
|
|
|
++ mask = VisualIDMask;
|
|
|
++
|
|
|
++ vinfo = XGetVisualInfo(dpy, mask, &templ, &n);
|
|
|
++ return vinfo;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++key_usage(void)
|
|
|
++{
|
|
|
++ printf("Keyboard:\n");
|
|
|
++ printf(" z - display Z buffer\n");
|
|
|
++ printf(" s - display stencil buffer\n");
|
|
|
++ printf(" f - display front color buffer\n");
|
|
|
++ printf(" b - display back buffer\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++usage(void)
|
|
|
++{
|
|
|
++ printf("Usage: glxsnoop [-display dpy] windowID\n");
|
|
|
++ key_usage();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++parse_opts(int argc, char *argv[])
|
|
|
++{
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-h") == 0) {
|
|
|
++ usage();
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ DisplayName = argv[i + 1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ if (argv[i][0] == '0' && argv[i][1] == 'x') {
|
|
|
++ /* hex */
|
|
|
++ WindowID = strtol(argv[i], NULL, 16);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ WindowID = atoi(argv[i]);
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!WindowID) {
|
|
|
++ usage();
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main( int argc, char *argv[] )
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ VisualID vid;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ Window win;
|
|
|
++
|
|
|
++ parse_opts(argc, argv);
|
|
|
++
|
|
|
++ key_usage();
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(DisplayName);
|
|
|
++
|
|
|
++ /* find the VisualID for the named window */
|
|
|
++ vid = get_window_visualid(dpy, WindowID);
|
|
|
++ get_window_size(dpy, WindowID, &Width, &Height);
|
|
|
++
|
|
|
++ visinfo = visualid_to_visualinfo(dpy, vid);
|
|
|
++
|
|
|
++ Context = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!Context) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ win = make_gl_window(dpy, visinfo, Width, Height);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ update_window_title(dpy, win);
|
|
|
++
|
|
|
++ event_loop( dpy, win );
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/glxswapcontrol.c Mesa-7.8.1.patched/progs/xdemos/glxswapcontrol.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/glxswapcontrol.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/glxswapcontrol.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,893 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++/*
|
|
|
++ * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT)
|
|
|
++ * Port by Brian Paul 23 March 2001
|
|
|
++ *
|
|
|
++ * Modified by Ian Romanick <idr@us.ibm.com> 09 April 2003 to support
|
|
|
++ * GLX_{MESA,SGI}_swap_control and GLX_OML_sync_control.
|
|
|
++ *
|
|
|
++ * Command line options:
|
|
|
++ * -display Name of the display to use.
|
|
|
++ * -info print GL implementation information
|
|
|
++ * -swap N Attempt to set the swap interval to 1/N second
|
|
|
++ * -forcegetrate Get the display refresh rate even if the required GLX
|
|
|
++ * extension is not supported.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <math.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#ifndef __VMS
|
|
|
++/*# include <stdint.h>*/
|
|
|
++#endif
|
|
|
++# define GLX_GLXEXT_PROTOTYPES
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++#ifndef GLX_MESA_swap_control
|
|
|
++typedef GLint ( * PFNGLXSWAPINTERVALMESAPROC) (unsigned interval);
|
|
|
++typedef GLint ( * PFNGLXGETSWAPINTERVALMESAPROC) ( void );
|
|
|
++#endif
|
|
|
++
|
|
|
++#if !defined( GLX_OML_sync_control ) && defined( _STDINT_H )
|
|
|
++#define GLX_OML_sync_control 1
|
|
|
++typedef Bool ( * PFNGLXGETMSCRATEOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
|
|
|
++#endif
|
|
|
++
|
|
|
++#ifndef GLX_MESA_swap_frame_usage
|
|
|
++#define GLX_MESA_swap_frame_usage 1
|
|
|
++typedef int ( * PFNGLXGETFRAMEUSAGEMESAPROC) (Display *dpy, GLXDrawable drawable, float * usage );
|
|
|
++#endif
|
|
|
++
|
|
|
++#define BENCHMARK
|
|
|
++
|
|
|
++PFNGLXGETFRAMEUSAGEMESAPROC get_frame_usage = NULL;
|
|
|
++
|
|
|
++#ifdef BENCHMARK
|
|
|
++
|
|
|
++/* XXX this probably isn't very portable */
|
|
|
++
|
|
|
++#include <sys/time.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++#define NUL '\0'
|
|
|
++
|
|
|
++/* return current time (in seconds) */
|
|
|
++static int
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ struct timeval tv;
|
|
|
++#ifdef __VMS
|
|
|
++ (void) gettimeofday(&tv, NULL );
|
|
|
++#else
|
|
|
++ struct timezone tz;
|
|
|
++ (void) gettimeofday(&tv, &tz);
|
|
|
++#endif
|
|
|
++ return (int) tv.tv_sec;
|
|
|
++}
|
|
|
++
|
|
|
++#else /*BENCHMARK*/
|
|
|
++
|
|
|
++/* dummy */
|
|
|
++static int
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++#endif /*BENCHMARK*/
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++#ifndef M_PI
|
|
|
++#define M_PI 3.14159265
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
|
|
|
++static GLint gear1, gear2, gear3;
|
|
|
++static GLfloat angle = 0.0;
|
|
|
++
|
|
|
++static GLboolean has_OML_sync_control = GL_FALSE;
|
|
|
++static GLboolean has_SGI_swap_control = GL_FALSE;
|
|
|
++static GLboolean has_MESA_swap_control = GL_FALSE;
|
|
|
++static GLboolean has_MESA_swap_frame_usage = GL_FALSE;
|
|
|
++
|
|
|
++static char ** extension_table = NULL;
|
|
|
++static unsigned num_extensions;
|
|
|
++
|
|
|
++static GLboolean use_ztrick = GL_FALSE;
|
|
|
++static GLfloat aspectX = 1.0f, aspectY = 1.0f;
|
|
|
++
|
|
|
++/*
|
|
|
++ *
|
|
|
++ * Draw a gear wheel. You'll probably want to call this function when
|
|
|
++ * building a display list since we do a lot of trig here.
|
|
|
++ *
|
|
|
++ * Input: inner_radius - radius of hole at center
|
|
|
++ * outer_radius - radius at center of teeth
|
|
|
++ * width - width of gear
|
|
|
++ * teeth - number of teeth
|
|
|
++ * tooth_depth - depth of tooth
|
|
|
++ */
|
|
|
++static void
|
|
|
++gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
|
|
|
++ GLint teeth, GLfloat tooth_depth)
|
|
|
++{
|
|
|
++ GLint i;
|
|
|
++ GLfloat r0, r1, r2;
|
|
|
++ GLfloat angle, da;
|
|
|
++ GLfloat u, v, len;
|
|
|
++
|
|
|
++ r0 = inner_radius;
|
|
|
++ r1 = outer_radius - tooth_depth / 2.0;
|
|
|
++ r2 = outer_radius + tooth_depth / 2.0;
|
|
|
++
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ /* draw front face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw front sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, -1.0);
|
|
|
++
|
|
|
++ /* draw back face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw back sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw outward faces of teeth */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ u = r2 * cos(angle + da) - r1 * cos(angle);
|
|
|
++ v = r2 * sin(angle + da) - r1 * sin(angle);
|
|
|
++ len = sqrt(u * u + v * v);
|
|
|
++ u /= len;
|
|
|
++ v /= len;
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
|
|
|
++ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glShadeModel(GL_SMOOTH);
|
|
|
++
|
|
|
++ /* draw inside radius cylinder */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glNormal3f(-cos(angle), -sin(angle), 0.0);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw(void)
|
|
|
++{
|
|
|
++ if ( use_ztrick ) {
|
|
|
++ static GLboolean flip = GL_FALSE;
|
|
|
++ static const GLfloat vert[4][3] = {
|
|
|
++ { -1, -1, -0.999 },
|
|
|
++ { 1, -1, -0.999 },
|
|
|
++ { 1, 1, -0.999 },
|
|
|
++ { -1, 1, -0.999 }
|
|
|
++ };
|
|
|
++ static const GLfloat col[4][3] = {
|
|
|
++ { 1.0, 0.6, 0.0 },
|
|
|
++ { 1.0, 0.6, 0.0 },
|
|
|
++ { 0.0, 0.0, 0.0 },
|
|
|
++ { 0.0, 0.0, 0.0 },
|
|
|
++ };
|
|
|
++
|
|
|
++ if ( flip ) {
|
|
|
++ glDepthRange(0, 0.5);
|
|
|
++ glDepthFunc(GL_LEQUAL);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glDepthRange(1.0, 0.4999);
|
|
|
++ glDepthFunc(GL_GEQUAL);
|
|
|
++ }
|
|
|
++
|
|
|
++ flip = !flip;
|
|
|
++
|
|
|
++ /* The famous Quake "Z trick" only works when the whole screen is
|
|
|
++ * re-drawn each frame.
|
|
|
++ */
|
|
|
++
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-1, 1, -1, 1, -1, 1);
|
|
|
++ glDisable(GL_LIGHTING);
|
|
|
++ glShadeModel(GL_SMOOTH);
|
|
|
++
|
|
|
++ glEnableClientState( GL_VERTEX_ARRAY );
|
|
|
++ glEnableClientState( GL_COLOR_ARRAY );
|
|
|
++ glVertexPointer( 3, GL_FLOAT, 0, vert );
|
|
|
++ glColorPointer( 3, GL_FLOAT, 0, col );
|
|
|
++ glDrawArrays( GL_POLYGON, 0, 4 );
|
|
|
++ glDisableClientState( GL_COLOR_ARRAY );
|
|
|
++ glDisableClientState( GL_VERTEX_ARRAY );
|
|
|
++
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-aspectX, aspectX, -aspectY, aspectY, 5.0, 60.0);
|
|
|
++
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -45.0);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++ }
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(view_rotx, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(view_roty, 0.0, 1.0, 0.0);
|
|
|
++ glRotatef(view_rotz, 0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.0, -2.0, 0.0);
|
|
|
++ glRotatef(angle, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear1);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(3.1, -2.0, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear2);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-3.1, 4.2, 0.0);
|
|
|
++ glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear3);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* new window size or exposure */
|
|
|
++static void
|
|
|
++reshape(int width, int height)
|
|
|
++{
|
|
|
++ if (width > height) {
|
|
|
++ aspectX = (GLfloat) width / (GLfloat) height;
|
|
|
++ aspectY = 1.0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ aspectX = 1.0;
|
|
|
++ aspectY = (GLfloat) height / (GLfloat) width;
|
|
|
++ }
|
|
|
++
|
|
|
++ glViewport(0, 0, (GLint) width, (GLint) height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++
|
|
|
++ glFrustum(-aspectX, aspectX, -aspectY, aspectY, 5.0, 60.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -45.0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++init(void)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
|
|
|
++ static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
|
|
|
++ static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
|
|
|
++ static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
|
|
|
++
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ /* make the gears */
|
|
|
++ gear1 = glGenLists(1);
|
|
|
++ glNewList(gear1, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
|
|
|
++ gear(1.0, 4.0, 1.0, 20, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear2 = glGenLists(1);
|
|
|
++ glNewList(gear2, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
|
|
|
++ gear(0.5, 2.0, 2.0, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ gear3 = glGenLists(1);
|
|
|
++ glNewList(gear3, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
|
|
|
++ gear(1.3, 2.0, 0.5, 10, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Remove window border/decorations.
|
|
|
++ */
|
|
|
++static void
|
|
|
++no_border( Display *dpy, Window w)
|
|
|
++{
|
|
|
++ static const unsigned MWM_HINTS_DECORATIONS = (1 << 1);
|
|
|
++ static const int PROP_MOTIF_WM_HINTS_ELEMENTS = 5;
|
|
|
++
|
|
|
++ typedef struct
|
|
|
++ {
|
|
|
++ unsigned long flags;
|
|
|
++ unsigned long functions;
|
|
|
++ unsigned long decorations;
|
|
|
++ long inputMode;
|
|
|
++ unsigned long status;
|
|
|
++ } PropMotifWmHints;
|
|
|
++
|
|
|
++ PropMotifWmHints motif_hints;
|
|
|
++ Atom prop, proptype;
|
|
|
++ unsigned long flags = 0;
|
|
|
++
|
|
|
++ /* setup the property */
|
|
|
++ motif_hints.flags = MWM_HINTS_DECORATIONS;
|
|
|
++ motif_hints.decorations = flags;
|
|
|
++
|
|
|
++ /* get the atom for the property */
|
|
|
++ prop = XInternAtom( dpy, "_MOTIF_WM_HINTS", True );
|
|
|
++ if (!prop) {
|
|
|
++ /* something went wrong! */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* not sure this is correct, seems to work, XA_WM_HINTS didn't work */
|
|
|
++ proptype = prop;
|
|
|
++
|
|
|
++ XChangeProperty( dpy, w, /* display, window */
|
|
|
++ prop, proptype, /* property, type */
|
|
|
++ 32, /* format: 32-bit datums */
|
|
|
++ PropModeReplace, /* mode */
|
|
|
++ (unsigned char *) &motif_hints, /* data */
|
|
|
++ PROP_MOTIF_WM_HINTS_ELEMENTS /* nelements */
|
|
|
++ );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window( Display *dpy, const char *name,
|
|
|
++ int x, int y, int width, int height, GLboolean fullscreen,
|
|
|
++ Window *winRet, GLXContext *ctxRet)
|
|
|
++{
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ if (fullscreen) {
|
|
|
++ x = y = 0;
|
|
|
++ width = DisplayWidth( dpy, scrnum );
|
|
|
++ height = DisplayHeight( dpy, scrnum );
|
|
|
++ }
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attrib );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (fullscreen)
|
|
|
++ no_border(dpy, win);
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(visinfo);
|
|
|
++
|
|
|
++ *winRet = win;
|
|
|
++ *ctxRet = ctx;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ float frame_usage = 0.0;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ while (XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ /* we'll redraw below */
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ reshape(event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ view_roty += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Right) {
|
|
|
++ view_roty -= 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Up) {
|
|
|
++ view_rotx += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Down) {
|
|
|
++ view_rotx -= 5.0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ /* next frame */
|
|
|
++ angle += 2.0;
|
|
|
++
|
|
|
++ draw();
|
|
|
++
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++
|
|
|
++ if ( get_frame_usage != NULL ) {
|
|
|
++ GLfloat temp;
|
|
|
++
|
|
|
++ (*get_frame_usage)( dpy, win, & temp );
|
|
|
++ frame_usage += temp;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* calc framerate */
|
|
|
++ {
|
|
|
++ static int t0 = -1;
|
|
|
++ static int frames = 0;
|
|
|
++ int t = current_time();
|
|
|
++
|
|
|
++ if (t0 < 0)
|
|
|
++ t0 = t;
|
|
|
++
|
|
|
++ frames++;
|
|
|
++
|
|
|
++ if (t - t0 >= 5.0) {
|
|
|
++ GLfloat seconds = t - t0;
|
|
|
++ GLfloat fps = frames / seconds;
|
|
|
++ if ( get_frame_usage != NULL ) {
|
|
|
++ printf("%d frames in %3.1f seconds = %6.3f FPS (%3.1f%% usage)\n",
|
|
|
++ frames, seconds, fps,
|
|
|
++ (frame_usage * 100.0) / (float) frames );
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("%d frames in %3.1f seconds = %6.3f FPS\n",
|
|
|
++ frames, seconds, fps);
|
|
|
++ }
|
|
|
++
|
|
|
++ t0 = t;
|
|
|
++ frames = 0;
|
|
|
++ frame_usage = 0.0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Display the refresh rate of the display using the GLX_OML_sync_control
|
|
|
++ * extension.
|
|
|
++ */
|
|
|
++static void
|
|
|
++show_refresh_rate( Display * dpy )
|
|
|
++{
|
|
|
++#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
|
|
|
++ PFNGLXGETMSCRATEOMLPROC get_msc_rate;
|
|
|
++ int32_t n;
|
|
|
++ int32_t d;
|
|
|
++
|
|
|
++ get_msc_rate = (PFNGLXGETMSCRATEOMLPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetMscRateOML" );
|
|
|
++ if ( get_msc_rate != NULL ) {
|
|
|
++ (*get_msc_rate)( dpy, glXGetCurrentDrawable(), &n, &d );
|
|
|
++ printf( "refresh rate: %.1fHz\n", (float) n / d );
|
|
|
++ return;
|
|
|
++ }
|
|
|
++#endif
|
|
|
++ printf( "glXGetMscRateOML not supported.\n" );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Fill in the table of extension strings from a supplied extensions string
|
|
|
++ * (as returned by glXQueryExtensionsString).
|
|
|
++ *
|
|
|
++ * \param string String of GLX extensions.
|
|
|
++ * \sa is_extension_supported
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_extension_table( const char * string )
|
|
|
++{
|
|
|
++ char ** string_tab;
|
|
|
++ unsigned num_strings;
|
|
|
++ unsigned base;
|
|
|
++ unsigned idx;
|
|
|
++ unsigned i;
|
|
|
++
|
|
|
++ /* Count the number of spaces in the string. That gives a base-line
|
|
|
++ * figure for the number of extension in the string.
|
|
|
++ */
|
|
|
++
|
|
|
++ num_strings = 1;
|
|
|
++ for ( i = 0 ; string[i] != NUL ; i++ ) {
|
|
|
++ if ( string[i] == ' ' ) {
|
|
|
++ num_strings++;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ string_tab = (char **) malloc( sizeof( char * ) * num_strings );
|
|
|
++ if ( string_tab == NULL ) {
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ base = 0;
|
|
|
++ idx = 0;
|
|
|
++
|
|
|
++ while ( string[ base ] != NUL ) {
|
|
|
++ /* Determine the length of the next extension string.
|
|
|
++ */
|
|
|
++
|
|
|
++ for ( i = 0
|
|
|
++ ; (string[ base + i ] != NUL) && (string[ base + i ] != ' ')
|
|
|
++ ; i++ ) {
|
|
|
++ /* empty */ ;
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( i > 0 ) {
|
|
|
++ /* If the string was non-zero length, add it to the table. We
|
|
|
++ * can get zero length strings if there is a space at the end of
|
|
|
++ * the string or if there are two (or more) spaces next to each
|
|
|
++ * other in the string.
|
|
|
++ */
|
|
|
++
|
|
|
++ string_tab[ idx ] = malloc( sizeof( char ) * (i + 1) );
|
|
|
++ if ( string_tab[ idx ] == NULL ) {
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ (void) memcpy( string_tab[ idx ], & string[ base ], i );
|
|
|
++ string_tab[ idx ][i] = NUL;
|
|
|
++ idx++;
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ /* Skip to the start of the next extension string.
|
|
|
++ */
|
|
|
++
|
|
|
++ for ( base += i
|
|
|
++ ; (string[ base ] == ' ') && (string[ base ] != NUL)
|
|
|
++ ; base++ ) {
|
|
|
++ /* empty */ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ extension_table = string_tab;
|
|
|
++ num_extensions = idx;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Determine of an extension is supported. The extension string table
|
|
|
++ * must have already be initialized by calling \c make_extension_table.
|
|
|
++ *
|
|
|
++ * \praram ext Extension to be tested.
|
|
|
++ * \return GL_TRUE of the extension is supported, GL_FALSE otherwise.
|
|
|
++ * \sa make_extension_table
|
|
|
++ */
|
|
|
++static GLboolean
|
|
|
++is_extension_supported( const char * ext )
|
|
|
++{
|
|
|
++ unsigned i;
|
|
|
++
|
|
|
++ for ( i = 0 ; i < num_extensions ; i++ ) {
|
|
|
++ if ( strcmp( ext, extension_table[i] ) == 0 ) {
|
|
|
++ return GL_TRUE;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ return GL_FALSE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ char *dpyName = NULL;
|
|
|
++ int swap_interval = 1;
|
|
|
++ GLboolean do_swap_interval = GL_FALSE;
|
|
|
++ GLboolean force_get_rate = GL_FALSE;
|
|
|
++ GLboolean fullscreen = GL_FALSE;
|
|
|
++ GLboolean printInfo = GL_FALSE;
|
|
|
++ int i;
|
|
|
++ PFNGLXSWAPINTERVALMESAPROC set_swap_interval = NULL;
|
|
|
++ PFNGLXGETSWAPINTERVALMESAPROC get_swap_interval = NULL;
|
|
|
++ int width = 300, height = 300;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-info") == 0) {
|
|
|
++ printInfo = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-swap") == 0 && i + 1 < argc) {
|
|
|
++ swap_interval = atoi( argv[i+1] );
|
|
|
++ do_swap_interval = GL_TRUE;
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-forcegetrate") == 0) {
|
|
|
++ /* This option was put in because some DRI drivers don't support the
|
|
|
++ * full GLX_OML_sync_control extension, but they do support
|
|
|
++ * glXGetMscRateOML.
|
|
|
++ */
|
|
|
++ force_get_rate = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-fullscreen") == 0) {
|
|
|
++ fullscreen = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-ztrick") == 0) {
|
|
|
++ use_ztrick = GL_TRUE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-help") == 0) {
|
|
|
++ printf("Usage:\n");
|
|
|
++ printf(" gears [options]\n");
|
|
|
++ printf("Options:\n");
|
|
|
++ printf(" -help Print this information\n");
|
|
|
++ printf(" -display displayName Specify X display\n");
|
|
|
++ printf(" -info Display GL information\n");
|
|
|
++ printf(" -swap N Swap no more than once per N vertical refreshes\n");
|
|
|
++ printf(" -forcegetrate Try to use glXGetMscRateOML function\n");
|
|
|
++ printf(" -fullscreen Full-screen window\n");
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n", XDisplayName(dpyName));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ make_window(dpy, "glxgears", 0, 0, width, height, fullscreen, &win, &ctx);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ glXMakeCurrent(dpy, win, ctx);
|
|
|
++
|
|
|
++ make_extension_table( (char *) glXQueryExtensionsString(dpy,DefaultScreen(dpy)) );
|
|
|
++ has_OML_sync_control = is_extension_supported( "GLX_OML_sync_control" );
|
|
|
++ has_SGI_swap_control = is_extension_supported( "GLX_SGI_swap_control" );
|
|
|
++ has_MESA_swap_control = is_extension_supported( "GLX_MESA_swap_control" );
|
|
|
++ has_MESA_swap_frame_usage = is_extension_supported( "GLX_MESA_swap_frame_usage" );
|
|
|
++
|
|
|
++ if ( has_MESA_swap_control ) {
|
|
|
++ set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalMESA" );
|
|
|
++ get_swap_interval = (PFNGLXGETSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetSwapIntervalMESA" );
|
|
|
++ }
|
|
|
++ else if ( has_SGI_swap_control ) {
|
|
|
++ set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalSGI" );
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ if ( has_MESA_swap_frame_usage ) {
|
|
|
++ get_frame_usage = (PFNGLXGETFRAMEUSAGEMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetFrameUsageMESA" );
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ if (printInfo) {
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
|
|
|
++ if ( has_OML_sync_control || force_get_rate ) {
|
|
|
++ show_refresh_rate( dpy );
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( get_swap_interval != NULL ) {
|
|
|
++ printf("Default swap interval = %d\n", (*get_swap_interval)() );
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( do_swap_interval ) {
|
|
|
++ if ( set_swap_interval != NULL ) {
|
|
|
++ if ( ((swap_interval == 0) && !has_MESA_swap_control)
|
|
|
++ || (swap_interval < 0) ) {
|
|
|
++ printf( "Swap interval must be non-negative or greater than zero "
|
|
|
++ "if GLX_MESA_swap_control is not supported.\n" );
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ (*set_swap_interval)( swap_interval );
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( printInfo && (get_swap_interval != NULL) ) {
|
|
|
++ printf("Current swap interval = %d\n", (*get_swap_interval)() );
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Unable to set swap-interval. Neither GLX_SGI_swap_control "
|
|
|
++ "nor GLX_MESA_swap_control are supported.\n" );
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ init();
|
|
|
++
|
|
|
++ /* Set initial projection/viewing transformation.
|
|
|
++ * same as glxgears.c
|
|
|
++ */
|
|
|
++ reshape(width, height);
|
|
|
++
|
|
|
++ event_loop(dpy, win);
|
|
|
++
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/ipc.c Mesa-7.8.1.patched/progs/xdemos/ipc.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/ipc.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/ipc.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,264 @@
|
|
|
++/* Copyright (c) 2003 Tungsten Graphics, Inc.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining
|
|
|
++ * a copy of this software and associated documentation files ("the
|
|
|
++ * Software"), to deal in the Software without restriction, including
|
|
|
++ * without limitation the rights to use, copy, modify, merge, publish,
|
|
|
++ * distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
++ * permit persons to whom the Software is furnished to do so, subject to
|
|
|
++ * the following conditions: The above copyright notice, the Tungsten
|
|
|
++ * Graphics splash screen, and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software. THE SOFTWARE
|
|
|
++ * IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
|
++ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
|
++ * SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
|
++ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
|
++ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
|
|
|
++ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++/*
|
|
|
++ * Simple IPC API
|
|
|
++ * Brian Paul
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <assert.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <sys/types.h>
|
|
|
++#include <netinet/in.h>
|
|
|
++#include <netinet/tcp.h>
|
|
|
++#include <arpa/inet.h>
|
|
|
++#include <netdb.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <sys/socket.h>
|
|
|
++#include "ipc.h"
|
|
|
++
|
|
|
++#if defined(IRIX) || defined(irix)
|
|
|
++typedef int socklen_t;
|
|
|
++#endif
|
|
|
++
|
|
|
++#define NO_DELAY 1
|
|
|
++
|
|
|
++#define DEFAULT_MASTER_PORT 7011
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Return my hostname in <nameOut>.
|
|
|
++ * Return 1 for success, 0 for error.
|
|
|
++ */
|
|
|
++int
|
|
|
++MyHostName(char *nameOut, int maxNameLength)
|
|
|
++{
|
|
|
++ int k = gethostname(nameOut, maxNameLength);
|
|
|
++ return k==0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create a socket attached to a port. Later, we can call AcceptConnection
|
|
|
++ * on the socket returned from this function.
|
|
|
++ * Return the new socket number or -1 if error.
|
|
|
++ */
|
|
|
++int
|
|
|
++CreatePort(int *port)
|
|
|
++{
|
|
|
++ char hostname[1000];
|
|
|
++ struct sockaddr_in servaddr;
|
|
|
++ struct hostent *hp;
|
|
|
++ int so_reuseaddr = 1;
|
|
|
++ int tcp_nodelay = 1;
|
|
|
++ int sock, k;
|
|
|
++
|
|
|
++ /* create socket */
|
|
|
++ sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
++ assert(sock > 2);
|
|
|
++
|
|
|
++ /* get my host name */
|
|
|
++ k = gethostname(hostname, 1000);
|
|
|
++ assert(k == 0);
|
|
|
++
|
|
|
++ /* get hostent info */
|
|
|
++ hp = gethostbyname(hostname);
|
|
|
++ assert(hp);
|
|
|
++
|
|
|
++ /* initialize the servaddr struct */
|
|
|
++ memset(&servaddr, 0, sizeof(servaddr) );
|
|
|
++ servaddr.sin_family = AF_INET;
|
|
|
++ servaddr.sin_port = htons((unsigned short) (*port));
|
|
|
++ memcpy((char *) &servaddr.sin_addr, hp->h_addr,
|
|
|
++ sizeof(servaddr.sin_addr));
|
|
|
++
|
|
|
++ /* deallocate when we exit */
|
|
|
++ k = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
|
|
|
++ (char *) &so_reuseaddr, sizeof(so_reuseaddr));
|
|
|
++ assert(k==0);
|
|
|
++
|
|
|
++ /* send packets immediately */
|
|
|
++#if NO_DELAY
|
|
|
++ k = setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
|
|
|
++ (char *) &tcp_nodelay, sizeof(tcp_nodelay));
|
|
|
++ assert(k==0);
|
|
|
++#endif
|
|
|
++
|
|
|
++ if (*port == 0)
|
|
|
++ *port = DEFAULT_MASTER_PORT;
|
|
|
++
|
|
|
++ k = 1;
|
|
|
++ while (k && (*port < 65534)) {
|
|
|
++ /* bind our address to the socket */
|
|
|
++ servaddr.sin_port = htons((unsigned short) (*port));
|
|
|
++ k = bind(sock, (struct sockaddr *) &servaddr, sizeof(servaddr));
|
|
|
++ if (k)
|
|
|
++ *port = *port + 1;
|
|
|
++ }
|
|
|
++
|
|
|
++#if 0
|
|
|
++ printf("###### Real Port: %d\n", *port);
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* listen for connections */
|
|
|
++ k = listen(sock, 100);
|
|
|
++ assert(k == 0);
|
|
|
++
|
|
|
++ return sock;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Accept a connection on the named socket.
|
|
|
++ * Return a new socket for the new connection, or -1 if error.
|
|
|
++ */
|
|
|
++int
|
|
|
++AcceptConnection(int socket)
|
|
|
++{
|
|
|
++ struct sockaddr addr;
|
|
|
++ socklen_t addrLen;
|
|
|
++ int newSock;
|
|
|
++
|
|
|
++ addrLen = sizeof(addr);
|
|
|
++ newSock = accept(socket, &addr, &addrLen);
|
|
|
++ if (newSock == 1)
|
|
|
++ return -1;
|
|
|
++ else
|
|
|
++ return newSock;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Contact the server running on the given host on the named port.
|
|
|
++ * Return socket number or -1 if error.
|
|
|
++ */
|
|
|
++int
|
|
|
++Connect(const char *hostname, int port)
|
|
|
++{
|
|
|
++ struct sockaddr_in servaddr;
|
|
|
++ struct hostent *hp;
|
|
|
++ int sock, k;
|
|
|
++ int tcp_nodelay = 1;
|
|
|
++
|
|
|
++ assert(port);
|
|
|
++
|
|
|
++ sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
++ assert(sock >= 0);
|
|
|
++
|
|
|
++ hp = gethostbyname(hostname);
|
|
|
++ assert(hp);
|
|
|
++
|
|
|
++ memset(&servaddr, 0, sizeof(servaddr));
|
|
|
++ servaddr.sin_family = AF_INET;
|
|
|
++ servaddr.sin_port = htons((unsigned short) port);
|
|
|
++ memcpy((char *) &servaddr.sin_addr, hp->h_addr, sizeof(servaddr.sin_addr));
|
|
|
++
|
|
|
++ k = connect(sock, (struct sockaddr *) &servaddr, sizeof(servaddr));
|
|
|
++ if (k != 0) {
|
|
|
++ perror("Connect:");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++#if NO_DELAY
|
|
|
++ /* send packets immediately */
|
|
|
++ k = setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
|
|
|
++ (char *) &tcp_nodelay, sizeof(tcp_nodelay));
|
|
|
++ assert(k==0);
|
|
|
++#endif
|
|
|
++
|
|
|
++ return sock;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void
|
|
|
++CloseSocket(int socket)
|
|
|
++{
|
|
|
++ close(socket);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++SendData(int socket, const void *data, int bytes)
|
|
|
++{
|
|
|
++ int sent = 0;
|
|
|
++ int b;
|
|
|
++
|
|
|
++ while (sent < bytes) {
|
|
|
++ b = write(socket, (char *) data + sent, bytes - sent);
|
|
|
++ if (b <= 0)
|
|
|
++ return -1; /* something broke */
|
|
|
++ sent += b;
|
|
|
++ }
|
|
|
++ return sent;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++ReceiveData(int socket, void *data, int bytes)
|
|
|
++{
|
|
|
++ int received = 0, b;
|
|
|
++
|
|
|
++ while (received < bytes) {
|
|
|
++ b = read(socket, (char *) data + received, bytes - received);
|
|
|
++ if (b <= 0)
|
|
|
++ return -1;
|
|
|
++ received += b;
|
|
|
++ }
|
|
|
++ return received;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++SendString(int socket, const char *str)
|
|
|
++{
|
|
|
++ const int len = strlen(str);
|
|
|
++ int sent, b;
|
|
|
++
|
|
|
++ /* first, send a 4-byte length indicator */
|
|
|
++ b = write(socket, &len, sizeof(len));
|
|
|
++ if (b <= 0)
|
|
|
++ return -1;
|
|
|
++
|
|
|
++ sent = SendData(socket, str, len);
|
|
|
++ assert(sent == len);
|
|
|
++ return sent;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++ReceiveString(int socket, char *str, int maxLen)
|
|
|
++{
|
|
|
++ int len, received, b;
|
|
|
++
|
|
|
++ /* first, read 4 bytes to see how long of string to receive */
|
|
|
++ b = read(socket, &len, sizeof(len));
|
|
|
++ if (b <= 0)
|
|
|
++ return -1;
|
|
|
++
|
|
|
++ assert(len <= maxLen); /* XXX fix someday */
|
|
|
++ assert(len >= 0);
|
|
|
++ received = ReceiveData(socket, str, len);
|
|
|
++ assert(received != -1);
|
|
|
++ assert(received == len);
|
|
|
++ str[len] = 0;
|
|
|
++ return received;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/ipc.h Mesa-7.8.1.patched/progs/xdemos/ipc.h
|
|
|
+--- Mesa-7.8.1/progs/xdemos/ipc.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/ipc.h 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,16 @@
|
|
|
++#ifndef IPC_H
|
|
|
++#define IPC_H
|
|
|
++
|
|
|
++
|
|
|
++extern int MyHostName(char *nameOut, int maxNameLength);
|
|
|
++extern int CreatePort(int *port);
|
|
|
++extern int AcceptConnection(int socket);
|
|
|
++extern int Connect(const char *hostname, int port);
|
|
|
++extern void CloseSocket(int socket);
|
|
|
++extern int SendData(int socket, const void *data, int bytes);
|
|
|
++extern int ReceiveData(int socket, void *data, int bytes);
|
|
|
++extern int SendString(int socket, const char *str);
|
|
|
++extern int ReceiveString(int socket, char *str, int maxLen);
|
|
|
++
|
|
|
++
|
|
|
++#endif /* IPC_H */
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/Makefile Mesa-7.8.1.patched/progs/xdemos/Makefile
|
|
|
+--- Mesa-7.8.1/progs/xdemos/Makefile 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/Makefile 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,103 @@
|
|
|
++# progs/xdemos/Makefile
|
|
|
++
|
|
|
++TOP = ../..
|
|
|
++include $(TOP)/configs/current
|
|
|
++
|
|
|
++
|
|
|
++INCDIR = $(TOP)/include
|
|
|
++
|
|
|
++LIB_DEP = $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME)
|
|
|
++
|
|
|
++# Add X11 and pthread libs to satisfy GNU gold.
|
|
|
++APP_LIB_DEPS += -lX11 -lpthread
|
|
|
++
|
|
|
++LIBS = -L$(TOP)/$(LIB_DIR) -l$(GL_LIB) -L$(libdir) $(APP_LIB_DEPS)
|
|
|
++
|
|
|
++PROGS = \
|
|
|
++ corender \
|
|
|
++ glsync \
|
|
|
++ glthreads \
|
|
|
++ glxdemo \
|
|
|
++ glxgears \
|
|
|
++ glxgears_fbconfig \
|
|
|
++ glxgears_pixmap \
|
|
|
++ glxcontexts \
|
|
|
++ glxheads \
|
|
|
++ glxinfo \
|
|
|
++ glxpixmap \
|
|
|
++ glxpbdemo \
|
|
|
++ glxsnoop \
|
|
|
++ glxswapcontrol \
|
|
|
++ manywin \
|
|
|
++ msctest \
|
|
|
++ multictx \
|
|
|
++ offset \
|
|
|
++ omlsync \
|
|
|
++ overlay \
|
|
|
++ pbinfo \
|
|
|
++ pbdemo \
|
|
|
++ sharedtex \
|
|
|
++ sharedtex_mt \
|
|
|
++ texture_from_pixmap \
|
|
|
++ wincopy \
|
|
|
++ xfont \
|
|
|
++ xrotfontdemo
|
|
|
++
|
|
|
++# Don't build these by default because of extra library dependencies
|
|
|
++EXTRA_PROGS = \
|
|
|
++ shape \
|
|
|
++ yuvrect_client \
|
|
|
++ xdemo
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++##### RULES #####
|
|
|
++
|
|
|
++.o: $(LIB_DEP)
|
|
|
++ $(APP_CC) $(CFLAGS) $(LDFLAGS) $< $(LIBS) -o $@
|
|
|
++
|
|
|
++.c.o:
|
|
|
++ $(APP_CC) -I$(INCDIR) $(X11_INCLUDES) $(CFLAGS) $< -c -o $@
|
|
|
++
|
|
|
++
|
|
|
++##### TARGETS #####
|
|
|
++
|
|
|
++default: $(PROGS)
|
|
|
++
|
|
|
++$(PROGS): $(PROGS:%=%.o)
|
|
|
++
|
|
|
++extra: $(EXTRA_PROGS)
|
|
|
++
|
|
|
++
|
|
|
++clean:
|
|
|
++ -rm -f $(PROGS) $(EXTRA_PROGS)
|
|
|
++ -rm -f *.o *~
|
|
|
++
|
|
|
++
|
|
|
++# special cases
|
|
|
++pbutil.o: pbutil.h
|
|
|
++pbinfo.o: pbutil.h
|
|
|
++pbinfo: pbinfo.o pbutil.o
|
|
|
++ $(APP_CC) $(CFLAGS) $(LDFLAGS) pbinfo.o pbutil.o $(LIBS) -o $@
|
|
|
++
|
|
|
++pbdemo.o: pbutil.h
|
|
|
++pbdemo: pbdemo.o pbutil.o
|
|
|
++ $(APP_CC) $(CFLAGS) $(LDFLAGS) pbdemo.o pbutil.o $(LIBS) -o $@
|
|
|
++
|
|
|
++glxgears_fbconfig.o: pbutil.h
|
|
|
++glxgears_fbconfig: glxgears_fbconfig.o pbutil.o
|
|
|
++ $(APP_CC) $(CFLAGS) $(LDFLAGS) glxgears_fbconfig.o pbutil.o $(LIBS) -o $@
|
|
|
++
|
|
|
++xuserotfont.o: xuserotfont.h
|
|
|
++xrotfontdemo.o: xuserotfont.h
|
|
|
++xrotfontdemo: xrotfontdemo.o xuserotfont.o
|
|
|
++ $(APP_CC) $(CFLAGS) $(LDFLAGS) xrotfontdemo.o xuserotfont.o $(LIBS) -o $@
|
|
|
++
|
|
|
++ipc.o: ipc.h
|
|
|
++corender.o: ipc.h
|
|
|
++corender: corender.o ipc.o
|
|
|
++ $(APP_CC) $(CFLAGS) $(LDFLAGS) corender.o ipc.o $(LIBS) -o $@
|
|
|
++
|
|
|
++yuvrect_client: yuvrect_client.o
|
|
|
++ $(APP_CC) $(CFLAGS) $< $(LDFLAGS) $(LIBS) -l$(GLU_LIB) -o $@
|
|
|
++
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/manywin.c Mesa-7.8.1.patched/progs/xdemos/manywin.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/manywin.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/manywin.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,421 @@
|
|
|
++/*
|
|
|
++ * Create N GLX windows/contexts and render to them in round-robin order.
|
|
|
++ * Also, have the contexts share all texture objects.
|
|
|
++ * Press 'd' to delete a texture, 'u' to unbind it.
|
|
|
++ *
|
|
|
++ * Copyright (C) 2000 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <assert.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Each display/window/context:
|
|
|
++ */
|
|
|
++struct head {
|
|
|
++ char DisplayName[1000];
|
|
|
++ Display *Dpy;
|
|
|
++ Window Win;
|
|
|
++ GLXContext Context;
|
|
|
++ float Angle;
|
|
|
++ char Renderer[1000];
|
|
|
++ char Vendor[1000];
|
|
|
++ char Version[1000];
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++#define MAX_HEADS 200
|
|
|
++static struct head Heads[MAX_HEADS];
|
|
|
++static int NumHeads = 0;
|
|
|
++static GLboolean SwapSeparate = GL_TRUE;
|
|
|
++static GLuint TexObj = 0;
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Error(const char *display, const char *msg)
|
|
|
++{
|
|
|
++ fprintf(stderr, "Error on display %s - %s\n", XDisplayName(display), msg);
|
|
|
++ exit(1);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static struct head *
|
|
|
++AddHead(const char *displayName, const char *name)
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int width = 90, height = 90;
|
|
|
++ int xpos = 0, ypos = 0;
|
|
|
++
|
|
|
++ if (NumHeads >= MAX_HEADS)
|
|
|
++ return NULL;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(displayName);
|
|
|
++ if (!dpy) {
|
|
|
++ Error(displayName, "Unable to open display");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(dpy);
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attrib);
|
|
|
++ if (!visinfo) {
|
|
|
++ Error(displayName, "Unable to find RGB, double-buffered visual");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ xpos = (NumHeads % 10) * 100;
|
|
|
++ ypos = (NumHeads / 10) * 100;
|
|
|
++ printf("%d, %d\n", xpos, ypos);
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow(dpy, root, xpos, ypos, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++ if (!win) {
|
|
|
++ Error(displayName, "Couldn't create window");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (NumHeads == 0) {
|
|
|
++ ctx = glXCreateContext(dpy, visinfo, NULL, True);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* share textures & dlists with 0th context */
|
|
|
++ printf("sharing\n");
|
|
|
++ ctx = glXCreateContext(dpy, visinfo, Heads[0].Context, True);
|
|
|
++ }
|
|
|
++ if (!ctx) {
|
|
|
++ Error(displayName, "Couldn't create GLX context");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ if (!glXMakeCurrent(dpy, win, ctx)) {
|
|
|
++ Error(displayName, "glXMakeCurrent failed");
|
|
|
++ printf("glXMakeCurrent failed in Redraw()\n");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (NumHeads == 0) {
|
|
|
++ /* create texture object now */
|
|
|
++ static const GLubyte checker[2][2][4] = {
|
|
|
++ { {255, 255, 255, 255}, { 0, 0, 0, 255} },
|
|
|
++ { { 0, 0, 0, 0}, {255, 255, 255, 255} }
|
|
|
++ };
|
|
|
++ glGenTextures(1, &TexObj);
|
|
|
++ assert(TexObj);
|
|
|
++ glBindTexture(GL_TEXTURE_2D, TexObj);
|
|
|
++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGB,
|
|
|
++ GL_UNSIGNED_BYTE, checker);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* bind 0th context's texture in this context too */
|
|
|
++ assert(TexObj);
|
|
|
++ glBindTexture(GL_TEXTURE_2D, TexObj);
|
|
|
++ }
|
|
|
++ glEnable(GL_TEXTURE_2D);
|
|
|
++
|
|
|
++ /* save the info for this head */
|
|
|
++ {
|
|
|
++ struct head *h = &Heads[NumHeads];
|
|
|
++ const char * tmp;
|
|
|
++
|
|
|
++ if (strlen(name) + 1 > sizeof(h->DisplayName)) {
|
|
|
++ Error(displayName, "name string overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->DisplayName, name);
|
|
|
++
|
|
|
++ h->Dpy = dpy;
|
|
|
++ h->Win = win;
|
|
|
++ h->Context = ctx;
|
|
|
++ h->Angle = 0.0;
|
|
|
++
|
|
|
++ tmp = (char *) glGetString(GL_VERSION);
|
|
|
++ if (strlen(tmp) + 1 > sizeof(h->Version)) {
|
|
|
++ Error(displayName, "GL_VERSION string overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->Version, tmp);
|
|
|
++
|
|
|
++ tmp = (char *) glGetString(GL_VENDOR);
|
|
|
++ if (strlen(tmp) + 1 > sizeof(h->Vendor)) {
|
|
|
++ Error(displayName, "GL_VENDOR string overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->Vendor, tmp);
|
|
|
++
|
|
|
++ tmp = (char *) glGetString(GL_RENDERER);
|
|
|
++ if (strlen(tmp) + 1 > sizeof(h->Renderer)) {
|
|
|
++ Error(displayName, "GL_RENDERER string overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->Renderer, tmp);
|
|
|
++
|
|
|
++ NumHeads++;
|
|
|
++ return &Heads[NumHeads-1];
|
|
|
++ }
|
|
|
++
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++DestroyHeads(void)
|
|
|
++{
|
|
|
++ int i;
|
|
|
++ for (i = 0; i < NumHeads; i++) {
|
|
|
++ XDestroyWindow(Heads[i].Dpy, Heads[i].Win);
|
|
|
++ glXDestroyContext(Heads[i].Dpy, Heads[i].Context);
|
|
|
++ XCloseDisplay(Heads[i].Dpy);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Redraw(struct head *h)
|
|
|
++{
|
|
|
++ if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed");
|
|
|
++ printf("glXMakeCurrent failed in Redraw()\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ h->Angle += 1.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++ glClearColor(0.5, 0.5, 0.5, 1.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++
|
|
|
++ /* draw green triangle */
|
|
|
++ glColor3f(0.0, 1.0, 0.0);
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(h->Angle, 0, 0, 1);
|
|
|
++ glBegin(GL_TRIANGLES);
|
|
|
++ glTexCoord2f(0.5, 1.0); glVertex2f(0, 0.8);
|
|
|
++ glTexCoord2f(0.0, 0.0); glVertex2f(-0.8, -0.7);
|
|
|
++ glTexCoord2f(1.0, 0.0); glVertex2f(0.8, -0.7);
|
|
|
++ glEnd();
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ if (!SwapSeparate)
|
|
|
++ glXSwapBuffers(h->Dpy, h->Win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Swap(struct head *h)
|
|
|
++{
|
|
|
++ glXSwapBuffers(h->Dpy, h->Win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Resize(const struct head *h, unsigned int width, unsigned int height)
|
|
|
++{
|
|
|
++ if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed in Resize()");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ glFlush();
|
|
|
++ glViewport(0, 0, width, height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++EventLoop(void)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ int i;
|
|
|
++ for (i = 0; i < NumHeads; i++) {
|
|
|
++ struct head *h = &Heads[i];
|
|
|
++ while (XPending(h->Dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(h->Dpy, &event);
|
|
|
++ if (event.xany.window == h->Win) {
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ Redraw(h);
|
|
|
++ if (SwapSeparate)
|
|
|
++ Swap(h);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ Resize(h, event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buf[100];
|
|
|
++ KeySym keySym;
|
|
|
++ XComposeStatus stat;
|
|
|
++ XLookupString(&event.xkey, buf, sizeof(buf), &keySym, &stat);
|
|
|
++ switch (keySym) {
|
|
|
++ case XK_Escape:
|
|
|
++ return;
|
|
|
++ break;
|
|
|
++ case XK_d:
|
|
|
++ case XK_D:
|
|
|
++ printf("Delete Texture in window %d\n", i);
|
|
|
++ glXMakeCurrent(h->Dpy, h->Win, h->Context);
|
|
|
++ glDeleteTextures(1, &TexObj);
|
|
|
++ break;
|
|
|
++ case XK_u:
|
|
|
++ case XK_U:
|
|
|
++ printf("Unbind Texture in window %d\n", i);
|
|
|
++ glXMakeCurrent(h->Dpy, h->Win, h->Context);
|
|
|
++ glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ /*no-op*/ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("window mismatch\n");
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ /* redraw all windows */
|
|
|
++ for (i = 0; i < NumHeads; i++) {
|
|
|
++ Redraw(&Heads[i]);
|
|
|
++ }
|
|
|
++ /* swapbuffers on all windows, if not already done */
|
|
|
++ if (SwapSeparate) {
|
|
|
++ for (i = 0; i < NumHeads; i++) {
|
|
|
++ Swap(&Heads[i]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ usleep(1);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++PrintInfo(const struct head *h)
|
|
|
++{
|
|
|
++ printf("Name: %s\n", h->DisplayName);
|
|
|
++ printf(" Display: %p\n", (void *) h->Dpy);
|
|
|
++ printf(" Window: 0x%x\n", (int) h->Win);
|
|
|
++ printf(" Context: 0x%lx\n", (long) h->Context);
|
|
|
++ printf(" GL_VERSION: %s\n", h->Version);
|
|
|
++ printf(" GL_VENDOR: %s\n", h->Vendor);
|
|
|
++ printf(" GL_RENDERER: %s\n", h->Renderer);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ char *dpyName = NULL;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ if (argc == 1) {
|
|
|
++ printf("manywin: open N simultaneous glx windows\n");
|
|
|
++ printf("Usage:\n");
|
|
|
++ printf(" manywin [-s] numWindows\n");
|
|
|
++ printf("Options:\n");
|
|
|
++ printf(" -s = swap immediately after drawing (see src code)\n");
|
|
|
++ printf("Example:\n");
|
|
|
++ printf(" manywin 10\n");
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ int n = 3;
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-s") == 0) {
|
|
|
++ SwapSeparate = GL_FALSE;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-display") == 0 && i < argc) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ n = atoi(argv[i]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ if (n < 1)
|
|
|
++ n = 1;
|
|
|
++ if (n > MAX_HEADS)
|
|
|
++ n = MAX_HEADS;
|
|
|
++
|
|
|
++ printf("%d windows\n", n);
|
|
|
++ for (i = 0; i < n; i++) {
|
|
|
++ char name[100];
|
|
|
++ struct head *h;
|
|
|
++ sprintf(name, "%d", i);
|
|
|
++ h = AddHead(dpyName, name);
|
|
|
++ if (h) {
|
|
|
++ PrintInfo(h);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ EventLoop();
|
|
|
++ DestroyHeads();
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/msctest.c Mesa-7.8.1.patched/progs/xdemos/msctest.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/msctest.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/msctest.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,195 @@
|
|
|
++/*
|
|
|
++ * Copyright © 2009 Intel Corporation
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice (including the next
|
|
|
++ * paragraph) shall be included in all copies or substantial portions of the
|
|
|
++ * Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
++ * IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ * Authors:
|
|
|
++ * Jesse Barnes <jesse.barnes@intel.com>
|
|
|
++ *
|
|
|
++ */
|
|
|
++
|
|
|
++/** @file msctest.c
|
|
|
++ * Simple test for MSC functionality.
|
|
|
++ */
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glu.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <GL/glxext.h>
|
|
|
++#include <X11/X.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/Xutil.h>
|
|
|
++
|
|
|
++void (*get_sync_values)(Display *dpy, Window winGL, int64_t *ust, int64_t *msc, int64_t *sbc);
|
|
|
++void (*wait_sync)(Display *dpy, Window winGL, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
|
|
|
++
|
|
|
++static int GLXExtensionSupported(Display *dpy, const char *extension)
|
|
|
++{
|
|
|
++ const char *extensionsString, *pos;
|
|
|
++
|
|
|
++ extensionsString = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
|
|
|
++
|
|
|
++ pos = strstr(extensionsString, extension);
|
|
|
++
|
|
|
++ if (pos != NULL && (pos == extensionsString || pos[-1] == ' ') &&
|
|
|
++ (pos[strlen(extension)] == ' ' || pos[strlen(extension)] == '\0'))
|
|
|
++ return 1;
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++extern char *optarg;
|
|
|
++extern int optind, opterr, optopt;
|
|
|
++static char optstr[] = "v";
|
|
|
++
|
|
|
++static void usage(char *name)
|
|
|
++{
|
|
|
++ printf("usage: %s\n", name);
|
|
|
++ exit(-1);
|
|
|
++}
|
|
|
++
|
|
|
++int main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *disp;
|
|
|
++ XVisualInfo *pvi;
|
|
|
++ XSetWindowAttributes swa;
|
|
|
++ int attrib[14];
|
|
|
++ Window winGL;
|
|
|
++ GLXContext context;
|
|
|
++ int dummy;
|
|
|
++ Atom wmDelete;
|
|
|
++ int verbose = 0, width = 200, height = 200;
|
|
|
++ int c, i = 1;
|
|
|
++ int64_t ust, msc, sbc;
|
|
|
++
|
|
|
++ opterr = 0;
|
|
|
++ while ((c = getopt(argc, argv, optstr)) != -1) {
|
|
|
++ switch (c) {
|
|
|
++ case 'v':
|
|
|
++ verbose = 1;
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ usage(argv[0]);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ disp = XOpenDisplay(NULL);
|
|
|
++ if (!disp) {
|
|
|
++ fprintf(stderr, "failed to open display\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!glXQueryExtension(disp, &dummy, &dummy)) {
|
|
|
++ fprintf(stderr, "glXQueryExtension failed\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!GLXExtensionSupported(disp, "GLX_OML_sync_control")) {
|
|
|
++ fprintf(stderr, "GLX_OML_sync_control not supported, exiting\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ attrib[0] = GLX_RGBA;
|
|
|
++ attrib[1] = 1;
|
|
|
++ attrib[2] = GLX_RED_SIZE;
|
|
|
++ attrib[3] = 1;
|
|
|
++ attrib[4] = GLX_GREEN_SIZE;
|
|
|
++ attrib[5] = 1;
|
|
|
++ attrib[6] = GLX_BLUE_SIZE;
|
|
|
++ attrib[7] = 1;
|
|
|
++ attrib[8] = GLX_DOUBLEBUFFER;
|
|
|
++ attrib[9] = 1;
|
|
|
++ attrib[10] = None;
|
|
|
++
|
|
|
++ pvi = glXChooseVisual(disp, DefaultScreen(disp), attrib);
|
|
|
++ if (!pvi) {
|
|
|
++ fprintf(stderr, "failed to choose visual, exiting\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ context = glXCreateContext(disp, pvi, None, GL_TRUE);
|
|
|
++ if (!context) {
|
|
|
++ fprintf(stderr, "failed to create glx context\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ pvi->screen = DefaultScreen(disp);
|
|
|
++
|
|
|
++ swa.colormap = XCreateColormap(disp, RootWindow(disp, pvi->screen),
|
|
|
++ pvi->visual, AllocNone);
|
|
|
++ swa.border_pixel = 0;
|
|
|
++ swa.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
|
|
|
++ StructureNotifyMask;
|
|
|
++ winGL = XCreateWindow(disp, RootWindow(disp, pvi->screen),
|
|
|
++ 0, 0,
|
|
|
++ width, height,
|
|
|
++ 0, pvi->depth, InputOutput, pvi->visual,
|
|
|
++ CWBorderPixel | CWColormap | CWEventMask, &swa);
|
|
|
++ if (!winGL) {
|
|
|
++ fprintf(stderr, "window creation failed\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++ wmDelete = XInternAtom(disp, "WM_DELETE_WINDOW", True);
|
|
|
++ XSetWMProtocols(disp, winGL, &wmDelete, 1);
|
|
|
++
|
|
|
++ XSetStandardProperties(disp, winGL, "msc test", "msc text",
|
|
|
++ None, NULL, 0, NULL);
|
|
|
++
|
|
|
++ XMapRaised(disp, winGL);
|
|
|
++
|
|
|
++ glXMakeCurrent(disp, winGL, context);
|
|
|
++
|
|
|
++ get_sync_values = (void *)glXGetProcAddress((unsigned char *)"glXGetSyncValuesOML");
|
|
|
++ wait_sync = (void *)glXGetProcAddress((unsigned char *)"glXWaitForMscOML");
|
|
|
++
|
|
|
++ if (!get_sync_values || !wait_sync) {
|
|
|
++ fprintf(stderr, "failed to get sync values function\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ while (i++) {
|
|
|
++ get_sync_values(disp, winGL, &ust, &msc, &sbc);
|
|
|
++ fprintf(stderr, "ust: %llu, msc: %llu, sbc: %llu\n", ust, msc,
|
|
|
++ sbc);
|
|
|
++
|
|
|
++ /* Alternate colors to make tearing obvious */
|
|
|
++ if (i & 1)
|
|
|
++ glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
++ else
|
|
|
++ glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++ glXSwapBuffers(disp, winGL);
|
|
|
++ wait_sync(disp, winGL, 0, 60, 0, &ust, &msc, &sbc);
|
|
|
++ fprintf(stderr,
|
|
|
++ "wait returned ust: %llu, msc: %llu, sbc: %llu\n",
|
|
|
++ ust, msc, sbc);
|
|
|
++ sleep(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XDestroyWindow(disp, winGL);
|
|
|
++ glXDestroyContext(disp, context);
|
|
|
++ XCloseDisplay(disp);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/multictx.c Mesa-7.8.1.patched/progs/xdemos/multictx.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/multictx.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/multictx.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,585 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 2009 VMware, Inc. All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++/*
|
|
|
++ * Test rendering with two contexts into one window.
|
|
|
++ * Setup different rendering state for each context to check that
|
|
|
++ * context switching is handled properly.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * 6 Aug 2009
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <math.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include <sys/time.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++#ifndef M_PI
|
|
|
++#define M_PI 3.14159265
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++/** Event handler results: */
|
|
|
++#define NOP 0
|
|
|
++#define EXIT 1
|
|
|
++#define DRAW 2
|
|
|
++
|
|
|
++static GLfloat view_rotx = 0.0, view_roty = 210.0, view_rotz = 0.0;
|
|
|
++static GLint gear1, gear2;
|
|
|
++static GLfloat angle = 0.0;
|
|
|
++
|
|
|
++static GLboolean animate = GL_TRUE; /* Animation */
|
|
|
++
|
|
|
++
|
|
|
++static double
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ struct timeval tv;
|
|
|
++#ifdef __VMS
|
|
|
++ (void) gettimeofday(&tv, NULL );
|
|
|
++#else
|
|
|
++ struct timezone tz;
|
|
|
++ (void) gettimeofday(&tv, &tz);
|
|
|
++#endif
|
|
|
++ return (double) tv.tv_sec + tv.tv_usec / 1000000.0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ *
|
|
|
++ * Draw a gear wheel. You'll probably want to call this function when
|
|
|
++ * building a display list since we do a lot of trig here.
|
|
|
++ *
|
|
|
++ * Input: inner_radius - radius of hole at center
|
|
|
++ * outer_radius - radius at center of teeth
|
|
|
++ * width - width of gear
|
|
|
++ * teeth - number of teeth
|
|
|
++ * tooth_depth - depth of tooth
|
|
|
++ */
|
|
|
++static void
|
|
|
++gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
|
|
|
++ GLint teeth, GLfloat tooth_depth)
|
|
|
++{
|
|
|
++ GLint i;
|
|
|
++ GLfloat r0, r1, r2;
|
|
|
++ GLfloat angle, da;
|
|
|
++ GLfloat u, v, len;
|
|
|
++
|
|
|
++ r0 = inner_radius;
|
|
|
++ r1 = outer_radius - tooth_depth / 2.0;
|
|
|
++ r2 = outer_radius + tooth_depth / 2.0;
|
|
|
++
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ /* draw front face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw front sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glNormal3f(0.0, 0.0, -1.0);
|
|
|
++
|
|
|
++ /* draw back face */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ if (i < teeth) {
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw back sides of teeth */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ da = 2.0 * M_PI / teeth / 4.0;
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* draw outward faces of teeth */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i < teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
|
|
|
++ u = r2 * cos(angle + da) - r1 * cos(angle);
|
|
|
++ v = r2 * sin(angle + da) - r1 * sin(angle);
|
|
|
++ len = sqrt(u * u + v * v);
|
|
|
++ u /= len;
|
|
|
++ v /= len;
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
|
|
|
++ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
|
|
|
++ glNormal3f(v, -u, 0.0);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
|
|
|
++ -width * 0.5);
|
|
|
++ glNormal3f(cos(angle), sin(angle), 0.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
|
|
|
++ glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glShadeModel(GL_SMOOTH);
|
|
|
++
|
|
|
++ /* draw inside radius cylinder */
|
|
|
++ glBegin(GL_QUAD_STRIP);
|
|
|
++ for (i = 0; i <= teeth; i++) {
|
|
|
++ angle = i * 2.0 * M_PI / teeth;
|
|
|
++ glNormal3f(-cos(angle), -sin(angle), 0.0);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
|
|
|
++ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
|
|
|
++ }
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw(int ctx)
|
|
|
++{
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(view_rotx, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(view_roty + angle, 0.0, 1.0, 0.0);
|
|
|
++ glRotatef(view_rotz, 0.0, 0.0, 1.0);
|
|
|
++
|
|
|
++ if (ctx == 0) {
|
|
|
++ glDisable(GL_CULL_FACE);
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(angle, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear1);
|
|
|
++ glPopMatrix();
|
|
|
++ /* This should not effect the other context's rendering */
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++ glCullFace(GL_FRONT_AND_BACK);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
|
|
|
++ glCallList(gear2);
|
|
|
++ glPopMatrix();
|
|
|
++ }
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ /* this flush is important since we'll be switching contexts next */
|
|
|
++ glFlush();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++draw_frame(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2)
|
|
|
++{
|
|
|
++ static double tRot0 = -1.0;
|
|
|
++ double dt, t = current_time();
|
|
|
++
|
|
|
++ if (tRot0 < 0.0)
|
|
|
++ tRot0 = t;
|
|
|
++ dt = t - tRot0;
|
|
|
++ tRot0 = t;
|
|
|
++
|
|
|
++ if (animate) {
|
|
|
++ /* advance rotation for next frame */
|
|
|
++ angle += 70.0 * dt; /* 70 degrees per second */
|
|
|
++ if (angle > 3600.0)
|
|
|
++ angle -= 3600.0;
|
|
|
++ }
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, (GLXDrawable) win, ctx1);
|
|
|
++ draw(0);
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, (GLXDrawable) win, ctx2);
|
|
|
++ draw(1);
|
|
|
++
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* new window size or exposure */
|
|
|
++static void
|
|
|
++reshape(Display *dpy, Window win,
|
|
|
++ GLXContext ctx1, GLXContext ctx2, int width, int height)
|
|
|
++{
|
|
|
++ int i;
|
|
|
++
|
|
|
++ width /= 2;
|
|
|
++
|
|
|
++ /* loop: left half of window, right half of window */
|
|
|
++ for (i = 0; i < 2; i++) {
|
|
|
++ if (i == 0)
|
|
|
++ glXMakeCurrent(dpy, win, ctx1);
|
|
|
++ else
|
|
|
++ glXMakeCurrent(dpy, win, ctx2);
|
|
|
++
|
|
|
++ glViewport(width * i, 0, width, height);
|
|
|
++ glScissor(width * i, 0, width, height);
|
|
|
++
|
|
|
++ {
|
|
|
++ GLfloat h = (GLfloat) height / (GLfloat) width;
|
|
|
++
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -30.0);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++init(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
|
|
|
++ static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
|
|
|
++ static GLfloat green[4] = { 0.0, 0.8, 0.2, 0.5 };
|
|
|
++ /*static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };*/
|
|
|
++
|
|
|
++ /* first ctx */
|
|
|
++ {
|
|
|
++ static GLuint stipple[32] = {
|
|
|
++ 0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
|
|
|
++ 0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
|
|
|
++
|
|
|
++ 0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00,
|
|
|
++ 0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00,
|
|
|
++
|
|
|
++ 0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
|
|
|
++ 0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
|
|
|
++
|
|
|
++ 0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00,
|
|
|
++ 0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00
|
|
|
++ };
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, win, ctx1);
|
|
|
++
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ gear1 = glGenLists(1);
|
|
|
++ glNewList(gear1, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
|
|
|
++ gear(1.0, 4.0, 1.0, 20, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++ glEnable(GL_SCISSOR_TEST);
|
|
|
++ glClearColor(0.4, 0.4, 0.4, 1.0);
|
|
|
++
|
|
|
++ glPolygonStipple((GLubyte *) stipple);
|
|
|
++ glEnable(GL_POLYGON_STIPPLE);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* second ctx */
|
|
|
++ {
|
|
|
++ glXMakeCurrent(dpy, win, ctx2);
|
|
|
++
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ gear2 = glGenLists(1);
|
|
|
++ glNewList(gear2, GL_COMPILE);
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
|
|
|
++ gear(1.5, 3.0, 1.5, 16, 0.7);
|
|
|
++ glEndList();
|
|
|
++
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++ glEnable(GL_SCISSOR_TEST);
|
|
|
++ glClearColor(0.6, 0.6, 0.6, 1.0);
|
|
|
++
|
|
|
++ glEnable(GL_BLEND);
|
|
|
++ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and two context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window_and_contexts( Display *dpy, const char *name,
|
|
|
++ int x, int y, int width, int height,
|
|
|
++ Window *winRet,
|
|
|
++ GLXContext *ctxRet1,
|
|
|
++ GLXContext *ctxRet2)
|
|
|
++{
|
|
|
++ int attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attribs );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, x, y, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ *winRet = win;
|
|
|
++ *ctxRet1 = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ *ctxRet2 = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++
|
|
|
++ if (!*ctxRet1 || !*ctxRet2) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(visinfo);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Handle one X event.
|
|
|
++ * \return NOP, EXIT or DRAW
|
|
|
++ */
|
|
|
++static int
|
|
|
++handle_event(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2,
|
|
|
++ XEvent *event)
|
|
|
++{
|
|
|
++ (void) dpy;
|
|
|
++ (void) win;
|
|
|
++
|
|
|
++ switch (event->type) {
|
|
|
++ case Expose:
|
|
|
++ return DRAW;
|
|
|
++ case ConfigureNotify:
|
|
|
++ reshape(dpy, win, ctx1, ctx2,
|
|
|
++ event->xconfigure.width, event->xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event->xkey, 0);
|
|
|
++ if (code == XK_Left) {
|
|
|
++ view_roty += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Right) {
|
|
|
++ view_roty -= 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Up) {
|
|
|
++ view_rotx += 5.0;
|
|
|
++ }
|
|
|
++ else if (code == XK_Down) {
|
|
|
++ view_rotx -= 5.0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ r = XLookupString(&event->xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return EXIT;
|
|
|
++ }
|
|
|
++ else if (buffer[0] == 'a' || buffer[0] == 'A') {
|
|
|
++ animate = !animate;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ return DRAW;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ return NOP;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ int op;
|
|
|
++ while (!animate || XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ op = handle_event(dpy, win, ctx1, ctx2, &event);
|
|
|
++ if (op == EXIT)
|
|
|
++ return;
|
|
|
++ else if (op == DRAW)
|
|
|
++ break;
|
|
|
++ }
|
|
|
++
|
|
|
++ draw_frame(dpy, win, ctx1, ctx2);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ unsigned int winWidth = 800, winHeight = 400;
|
|
|
++ int x = 0, y = 0;
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx1, ctx2;
|
|
|
++ char *dpyName = NULL;
|
|
|
++ GLboolean printInfo = GL_FALSE;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n",
|
|
|
++ dpyName ? dpyName : getenv("DISPLAY"));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ make_window_and_contexts(dpy, "multictx", x, y, winWidth, winHeight,
|
|
|
++ &win, &ctx1, &ctx2);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ if (printInfo) {
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
|
|
|
++ }
|
|
|
++
|
|
|
++ init(dpy, win, ctx1, ctx2);
|
|
|
++
|
|
|
++ /* Set initial projection/viewing transformation.
|
|
|
++ * We can't be sure we'll get a ConfigureNotify event when the window
|
|
|
++ * first appears.
|
|
|
++ */
|
|
|
++ reshape(dpy, win, ctx1, ctx2, winWidth, winHeight);
|
|
|
++
|
|
|
++ event_loop(dpy, win, ctx1, ctx2);
|
|
|
++
|
|
|
++ glDeleteLists(gear1, 1);
|
|
|
++ glDeleteLists(gear2, 1);
|
|
|
++ glXDestroyContext(dpy, ctx1);
|
|
|
++ glXDestroyContext(dpy, ctx2);
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/offset.c Mesa-7.8.1.patched/progs/xdemos/offset.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/offset.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/offset.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,343 @@
|
|
|
++/****************************************************************************
|
|
|
++Copyright 1995 by Silicon Graphics Incorporated, Mountain View, California.
|
|
|
++
|
|
|
++ All Rights Reserved
|
|
|
++
|
|
|
++Permission to use, copy, modify, and distribute this software and its
|
|
|
++documentation for any purpose and without fee is hereby granted,
|
|
|
++provided that the above copyright notice appear in all copies and that
|
|
|
++both that copyright notice and this permission notice appear in
|
|
|
++supporting documentation, and that the name of Silicon Graphics not be
|
|
|
++used in advertising or publicity pertaining to distribution of the
|
|
|
++software without specific, written prior permission.
|
|
|
++
|
|
|
++SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
++INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
++EVENT SHALL SILICON GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
|
++CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
|
|
|
++USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
|
++OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
++PERFORMANCE OF THIS SOFTWARE.
|
|
|
++
|
|
|
++****************************************************************************/
|
|
|
++
|
|
|
++/*
|
|
|
++ * Derived from code written by Kurt Akeley, November 1992
|
|
|
++ *
|
|
|
++ * Uses PolygonOffset to draw hidden-line images. PolygonOffset
|
|
|
++ * shifts the z values of polygons an amount that is
|
|
|
++ * proportional to their slope in screen z. This keeps
|
|
|
++ * the lines, which are drawn without displacement, from
|
|
|
++ * interacting with their respective polygons, and
|
|
|
++ * thus eliminates line dropouts.
|
|
|
++ *
|
|
|
++ * The left image shows an ordinary antialiased wireframe image.
|
|
|
++ * The center image shows an antialiased hidden-line image without
|
|
|
++ * PolygonOffset.
|
|
|
++ * The right image shows an antialiased hidden-line image using
|
|
|
++ * PolygonOffset to reduce artifacts.
|
|
|
++ *
|
|
|
++ * Drag with a mouse button pressed to rotate the models.
|
|
|
++ * Press the escape key to exit.
|
|
|
++ */
|
|
|
++
|
|
|
++/*
|
|
|
++ * Modified for OpenGL 1.1 glPolygonOffset() conventions
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++
|
|
|
++#undef GL_EXT_polygon_offset /* use GL 1.1 version instead of extension */
|
|
|
++
|
|
|
++
|
|
|
++#ifndef EXIT_FAILURE
|
|
|
++# define EXIT_FAILURE 1
|
|
|
++#endif
|
|
|
++#ifndef EXIT_SUCCESS
|
|
|
++# define EXIT_SUCCESS 0
|
|
|
++#endif
|
|
|
++
|
|
|
++#define MAXQUAD 6
|
|
|
++
|
|
|
++typedef float Vertex[3];
|
|
|
++
|
|
|
++typedef Vertex Quad[4];
|
|
|
++
|
|
|
++/* data to define the six faces of a unit cube */
|
|
|
++Quad quads[MAXQUAD] = {
|
|
|
++ { {0,0,0}, {0,0,1}, {0,1,1}, {0,1,0} }, /* x = 0 */
|
|
|
++ { {0,0,0}, {1,0,0}, {1,0,1}, {0,0,1} }, /* y = 0 */
|
|
|
++ { {0,0,0}, {1,0,0}, {1,1,0}, {0,1,0} }, /* z = 0 */
|
|
|
++ { {1,0,0}, {1,0,1}, {1,1,1}, {1,1,0} }, /* x = 1 */
|
|
|
++ { {0,1,0}, {1,1,0}, {1,1,1}, {0,1,1} }, /* y = 1 */
|
|
|
++ { {0,0,1}, {1,0,1}, {1,1,1}, {0,1,1} } /* z = 1 */
|
|
|
++};
|
|
|
++
|
|
|
++#define WIREFRAME 0
|
|
|
++#define HIDDEN_LINE 1
|
|
|
++
|
|
|
++static void error(const char* prog, const char* msg);
|
|
|
++static void cubes(int mx, int my, int mode);
|
|
|
++static void fill(Quad quad);
|
|
|
++static void outline(Quad quad);
|
|
|
++static void draw_hidden(Quad quad, int mode, int face);
|
|
|
++static void process_input(Display *dpy, Window win);
|
|
|
++static int query_extension(char* extName);
|
|
|
++
|
|
|
++static int attributeList[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 1, None };
|
|
|
++
|
|
|
++static int dimension = 3;
|
|
|
++
|
|
|
++static float Scale = 1.0;
|
|
|
++
|
|
|
++
|
|
|
++int main(int argc, char** argv) {
|
|
|
++ Display *dpy;
|
|
|
++ XVisualInfo *vi;
|
|
|
++ XSetWindowAttributes swa;
|
|
|
++ Window win;
|
|
|
++ GLXContext cx;
|
|
|
++ GLint z;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(0);
|
|
|
++ if (!dpy) error(argv[0], "can't open display");
|
|
|
++
|
|
|
++ vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeList);
|
|
|
++ if (!vi) error(argv[0], "no suitable visual");
|
|
|
++
|
|
|
++ cx = glXCreateContext(dpy, vi, 0, GL_TRUE);
|
|
|
++
|
|
|
++ swa.colormap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
|
|
|
++ vi->visual, AllocNone);
|
|
|
++
|
|
|
++ swa.border_pixel = 0;
|
|
|
++ swa.event_mask = ExposureMask | StructureNotifyMask | KeyPressMask |
|
|
|
++ ButtonPressMask | ButtonMotionMask;
|
|
|
++ win = XCreateWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, 900, 300,
|
|
|
++ 0, vi->depth, InputOutput, vi->visual,
|
|
|
++ CWBorderPixel|CWColormap|CWEventMask, &swa);
|
|
|
++ XStoreName(dpy, win, "hiddenline");
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, win, cx);
|
|
|
++
|
|
|
++ /* check for the polygon offset extension */
|
|
|
++#ifndef GL_VERSION_1_1
|
|
|
++ if (!query_extension("GL_EXT_polygon_offset"))
|
|
|
++ error(argv[0], "polygon_offset extension is not available");
|
|
|
++#else
|
|
|
++ (void) query_extension;
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* set up viewing parameters */
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glFrustum(-1, 1, -1, 1, 6, 20);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glTranslatef(0, 0, -15);
|
|
|
++
|
|
|
++ /* set other relevant state information */
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++
|
|
|
++ glGetIntegerv(GL_DEPTH_BITS, &z);
|
|
|
++ printf("GL_DEPTH_BITS = %d\n", z);
|
|
|
++
|
|
|
++#ifdef GL_EXT_polygon_offset
|
|
|
++ printf("using 1.0 offset extension\n");
|
|
|
++ glPolygonOffsetEXT( 1.0, 0.00001 );
|
|
|
++#else
|
|
|
++ printf("using 1.1 offset\n");
|
|
|
++ glPolygonOffset( 1.0, 0.5 );
|
|
|
++#endif
|
|
|
++
|
|
|
++ glShadeModel( GL_FLAT );
|
|
|
++ glDisable( GL_DITHER );
|
|
|
++
|
|
|
++ /* process events until the user presses ESC */
|
|
|
++ while (1) process_input(dpy, win);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++draw_scene(int mx, int my) {
|
|
|
++ glClearColor(0.25, 0.25, 0.25, 0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(-1.7, 0.0, 0.0);
|
|
|
++ cubes(mx, my, WIREFRAME);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ cubes(mx, my, HIDDEN_LINE);
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(1.7, 0.0, 0.0);
|
|
|
++#ifdef GL_EXT_polygon_offset
|
|
|
++ glEnable(GL_POLYGON_OFFSET_EXT);
|
|
|
++#else
|
|
|
++ glEnable(GL_POLYGON_OFFSET_FILL);
|
|
|
++#endif
|
|
|
++ glScalef(Scale, Scale, Scale);
|
|
|
++ cubes(mx, my, HIDDEN_LINE);
|
|
|
++#ifdef GL_EXT_polygon_offset
|
|
|
++ glDisable(GL_POLYGON_OFFSET_EXT);
|
|
|
++#else
|
|
|
++ glDisable(GL_POLYGON_OFFSET_FILL);
|
|
|
++#endif
|
|
|
++ glPopMatrix();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++cubes(int mx, int my, int mode) {
|
|
|
++ int x, y, z, i;
|
|
|
++
|
|
|
++ /* track the mouse */
|
|
|
++ glRotatef(mx / 2.0, 0, 1, 0);
|
|
|
++ glRotatef(my / 2.0, 1, 0, 0);
|
|
|
++
|
|
|
++ /* draw the lines as hidden polygons */
|
|
|
++ glTranslatef(-0.5, -0.5, -0.5);
|
|
|
++ glScalef(1.0/dimension, 1.0/dimension, 1.0/dimension);
|
|
|
++ for (z = 0; z < dimension; z++) {
|
|
|
++ for (y = 0; y < dimension; y++) {
|
|
|
++ for (x = 0; x < dimension; x++) {
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(x, y, z);
|
|
|
++ glScalef(0.8, 0.8, 0.8);
|
|
|
++ for (i = 0; i < MAXQUAD; i++)
|
|
|
++ draw_hidden(quads[i], mode, i);
|
|
|
++ glPopMatrix();
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++fill(Quad quad) {
|
|
|
++ /* draw a filled polygon */
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ glVertex3fv(quad[0]);
|
|
|
++ glVertex3fv(quad[1]);
|
|
|
++ glVertex3fv(quad[2]);
|
|
|
++ glVertex3fv(quad[3]);
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++outline(Quad quad) {
|
|
|
++ /* draw an outlined polygon */
|
|
|
++ glBegin(GL_LINE_LOOP);
|
|
|
++ glVertex3fv(quad[0]);
|
|
|
++ glVertex3fv(quad[1]);
|
|
|
++ glVertex3fv(quad[2]);
|
|
|
++ glVertex3fv(quad[3]);
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++draw_hidden(Quad quad, int mode, int face) {
|
|
|
++ static const GLfloat colors[3][3] = {
|
|
|
++ {0.5, 0.5, 0.0},
|
|
|
++ {0.8, 0.5, 0.0},
|
|
|
++ {0.0, 0.5, 0.8}
|
|
|
++ };
|
|
|
++ if (mode == HIDDEN_LINE) {
|
|
|
++ glColor3fv(colors[face % 3]);
|
|
|
++ fill(quad);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* draw the outline using white */
|
|
|
++ glColor3f(1, 1, 1);
|
|
|
++ outline(quad);
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++process_input(Display *dpy, Window win) {
|
|
|
++ XEvent event;
|
|
|
++ static int prevx, prevy;
|
|
|
++ static int deltax = 90, deltay = 40;
|
|
|
++
|
|
|
++ do {
|
|
|
++ char buf[31];
|
|
|
++ KeySym keysym;
|
|
|
++
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ switch(event.type) {
|
|
|
++ case Expose:
|
|
|
++ break;
|
|
|
++ case ConfigureNotify: {
|
|
|
++ /* this approach preserves a 1:1 viewport aspect ratio */
|
|
|
++ int vX, vY, vW, vH;
|
|
|
++ int eW = event.xconfigure.width, eH = event.xconfigure.height;
|
|
|
++ if (eW >= eH) {
|
|
|
++ vX = 0;
|
|
|
++ vY = (eH - eW) >> 1;
|
|
|
++ vW = vH = eW;
|
|
|
++ } else {
|
|
|
++ vX = (eW - eH) >> 1;
|
|
|
++ vY = 0;
|
|
|
++ vW = vH = eH;
|
|
|
++ }
|
|
|
++ glViewport(vX, vY, vW, vH);
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ (void) XLookupString(&event.xkey, buf, sizeof(buf), &keysym, NULL);
|
|
|
++ switch (keysym) {
|
|
|
++ case 'Z':
|
|
|
++ Scale *= 1.1;
|
|
|
++ break;
|
|
|
++ case 'z':
|
|
|
++ Scale *= 0.9;
|
|
|
++ break;
|
|
|
++ case XK_Escape:
|
|
|
++ exit(EXIT_SUCCESS);
|
|
|
++ default:
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ case ButtonPress:
|
|
|
++ prevx = event.xbutton.x;
|
|
|
++ prevy = event.xbutton.y;
|
|
|
++ break;
|
|
|
++ case MotionNotify:
|
|
|
++ deltax += (event.xbutton.x - prevx); prevx = event.xbutton.x;
|
|
|
++ deltay += (event.xbutton.y - prevy); prevy = event.xbutton.y;
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ } while (XPending(dpy));
|
|
|
++
|
|
|
++ draw_scene(deltax, deltay);
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++error(const char *prog, const char *msg) {
|
|
|
++ fprintf(stderr, "%s: %s\n", prog, msg);
|
|
|
++ exit(EXIT_FAILURE);
|
|
|
++}
|
|
|
++
|
|
|
++static int
|
|
|
++query_extension(char* extName) {
|
|
|
++ char *p = (char *) glGetString(GL_EXTENSIONS);
|
|
|
++ char *end = p + strlen(p);
|
|
|
++ while (p < end) {
|
|
|
++ int n = strcspn(p, " ");
|
|
|
++ if ((strlen(extName) == n) && (strncmp(extName, p, n) == 0))
|
|
|
++ return GL_TRUE;
|
|
|
++ p += (n + 1);
|
|
|
++ }
|
|
|
++ return GL_FALSE;
|
|
|
++}
|
|
|
++
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/omlsync.c Mesa-7.8.1.patched/progs/xdemos/omlsync.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/omlsync.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/omlsync.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,265 @@
|
|
|
++/*
|
|
|
++ * Copyright © 2007-2010 Intel Corporation
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice (including the next
|
|
|
++ * paragraph) shall be included in all copies or substantial portions of the
|
|
|
++ * Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
++ * IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ * Authors:
|
|
|
++ * Jesse Barnes <jesse.barnes@intel.com>
|
|
|
++ *
|
|
|
++ */
|
|
|
++
|
|
|
++/** @file omlsync.c
|
|
|
++ * The program is simple: it paints a window alternating colors (red &
|
|
|
++ * white) either as fast as possible or synchronized to vblank events
|
|
|
++ *
|
|
|
++ * If run normally, the program should display a window that exhibits
|
|
|
++ * significant tearing between red and white colors (e.g. you might get
|
|
|
++ * a "waterfall" effect of red and white horizontal bars).
|
|
|
++ *
|
|
|
++ * If run with the '-s b' option, the program should synchronize the
|
|
|
++ * window color changes with the vertical blank period, resulting in a
|
|
|
++ * window that looks orangish with a high frequency flicker (which may
|
|
|
++ * be invisible). If the window is moved to another screen, this
|
|
|
++ * property should be preserved. If the window spans two screens, it
|
|
|
++ * shouldn't tear on whichever screen most of the window is on; the
|
|
|
++ * portion on the other screen may show some tearing (like the
|
|
|
++ * waterfall effect above).
|
|
|
++ *
|
|
|
++ * Other options include '-w <width>' and '-h <height>' to set the
|
|
|
++ * window size.
|
|
|
++ */
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glu.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <GL/glxext.h>
|
|
|
++#include <X11/X.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/Xutil.h>
|
|
|
++
|
|
|
++Bool (*glXGetSyncValuesOML)(Display *dpy, GLXDrawable drawable,
|
|
|
++ int64_t *ust, int64_t *msc, int64_t *sbc);
|
|
|
++Bool (*glXGetMscRateOML)(Display *dpy, GLXDrawable drawable, int32_t *numerator,
|
|
|
++ int32_t *denominator);
|
|
|
++int64_t (*glXSwapBuffersMscOML)(Display *dpy, GLXDrawable drawable,
|
|
|
++ int64_t target_msc, int64_t divisor,
|
|
|
++ int64_t remainder);
|
|
|
++Bool (*glXWaitForMscOML)(Display *dpy, GLXDrawable drawable, int64_t target_msc,
|
|
|
++ int64_t divisor, int64_t remainder, int64_t *ust,
|
|
|
++ int64_t *msc, int64_t *sbc);
|
|
|
++Bool (*glXWaitForSbcOML)(Display *dpy, GLXDrawable drawable, int64_t target_sbc,
|
|
|
++ int64_t *ust, int64_t *msc, int64_t *sbc);
|
|
|
++int (*glXSwapInterval)(int interval);
|
|
|
++
|
|
|
++static int GLXExtensionSupported(Display *dpy, const char *extension)
|
|
|
++{
|
|
|
++ const char *extensionsString, *pos;
|
|
|
++
|
|
|
++ extensionsString = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
|
|
|
++
|
|
|
++ pos = strstr(extensionsString, extension);
|
|
|
++
|
|
|
++ if (pos != NULL && (pos == extensionsString || pos[-1] == ' ') &&
|
|
|
++ (pos[strlen(extension)] == ' ' || pos[strlen(extension)] == '\0'))
|
|
|
++ return 1;
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++extern char *optarg;
|
|
|
++extern int optind, opterr, optopt;
|
|
|
++static char optstr[] = "w:h:vd:r:n:i:";
|
|
|
++
|
|
|
++static void usage(char *name)
|
|
|
++{
|
|
|
++ printf("usage: %s [-w <width>] [-h <height>] ...\n", name);
|
|
|
++ printf("\t-d<divisor> - divisor for OML swap\n");
|
|
|
++ printf("\t-r<remainder> - remainder for OML swap\n");
|
|
|
++ printf("\t-n<interval> - wait interval for OML WaitMSC\n");
|
|
|
++ printf("\t-i<swap interval> - swap at most once every n frames\n");
|
|
|
++ printf("\t-v: verbose (print count)\n");
|
|
|
++ exit(-1);
|
|
|
++}
|
|
|
++
|
|
|
++int main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *disp;
|
|
|
++ XVisualInfo *pvi;
|
|
|
++ XSetWindowAttributes swa;
|
|
|
++ Window winGL;
|
|
|
++ GLXContext context;
|
|
|
++ int dummy;
|
|
|
++ Atom wmDelete;
|
|
|
++ int64_t ust, msc, sbc;
|
|
|
++ int width = 500, height = 500, verbose = 0, divisor = 0, remainder = 0,
|
|
|
++ wait_interval = 0, swap_interval = 1;
|
|
|
++ int c, i = 1;
|
|
|
++ int ret;
|
|
|
++ int db_attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ XSizeHints sizehints;
|
|
|
++
|
|
|
++ opterr = 0;
|
|
|
++ while ((c = getopt(argc, argv, optstr)) != -1) {
|
|
|
++ switch (c) {
|
|
|
++ case 'w':
|
|
|
++ width = atoi(optarg);
|
|
|
++ break;
|
|
|
++ case 'h':
|
|
|
++ height = atoi(optarg);
|
|
|
++ break;
|
|
|
++ case 'v':
|
|
|
++ verbose = 1;
|
|
|
++ break;
|
|
|
++ case 'd':
|
|
|
++ divisor = atoi(optarg);
|
|
|
++ break;
|
|
|
++ case 'r':
|
|
|
++ remainder = atoi(optarg);
|
|
|
++ break;
|
|
|
++ case 'n':
|
|
|
++ wait_interval = atoi(optarg);
|
|
|
++ break;
|
|
|
++ case 'i':
|
|
|
++ swap_interval = atoi(optarg);
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ usage(argv[0]);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ disp = XOpenDisplay(NULL);
|
|
|
++ if (!disp) {
|
|
|
++ fprintf(stderr, "failed to open display\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!glXQueryExtension(disp, &dummy, &dummy)) {
|
|
|
++ fprintf(stderr, "glXQueryExtension failed\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!GLXExtensionSupported(disp, "GLX_OML_sync_control")) {
|
|
|
++ fprintf(stderr, "GLX_OML_sync_control not supported\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!GLXExtensionSupported(disp, "GLX_MESA_swap_control")) {
|
|
|
++ fprintf(stderr, "GLX_MESA_swap_control not supported\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ pvi = glXChooseVisual(disp, DefaultScreen(disp), db_attribs);
|
|
|
++
|
|
|
++ if (!pvi) {
|
|
|
++ fprintf(stderr, "failed to choose visual, exiting\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ pvi->screen = DefaultScreen(disp);
|
|
|
++
|
|
|
++ swa.colormap = XCreateColormap(disp, RootWindow(disp, pvi->screen),
|
|
|
++ pvi->visual, AllocNone);
|
|
|
++ swa.border_pixel = 0;
|
|
|
++ swa.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
|
|
|
++ StructureNotifyMask;
|
|
|
++ winGL = XCreateWindow(disp, RootWindow(disp, pvi->screen),
|
|
|
++ 0, 0,
|
|
|
++ width, height,
|
|
|
++ 0, pvi->depth, InputOutput, pvi->visual,
|
|
|
++ CWBorderPixel | CWColormap | CWEventMask, &swa);
|
|
|
++ if (!winGL) {
|
|
|
++ fprintf(stderr, "window creation failed\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++ wmDelete = XInternAtom(disp, "WM_DELETE_WINDOW", True);
|
|
|
++ XSetWMProtocols(disp, winGL, &wmDelete, 1);
|
|
|
++
|
|
|
++ sizehints.x = 0;
|
|
|
++ sizehints.y = 0;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++
|
|
|
++ XSetNormalHints(disp, winGL, &sizehints);
|
|
|
++ XSetStandardProperties(disp, winGL, "glsync test", "glsync text",
|
|
|
++ None, NULL, 0, &sizehints);
|
|
|
++
|
|
|
++ context = glXCreateContext(disp, pvi, NULL, GL_TRUE);
|
|
|
++ if (!context) {
|
|
|
++ fprintf(stderr, "failed to create glx context\n");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ XMapWindow(disp, winGL);
|
|
|
++ ret = glXMakeCurrent(disp, winGL, context);
|
|
|
++ if (!ret) {
|
|
|
++ fprintf(stderr, "failed to make context current: %d\n", ret);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXGetSyncValuesOML = (void *)glXGetProcAddress((unsigned char *)"glXGetSyncValuesOML");
|
|
|
++ glXGetMscRateOML = (void *)glXGetProcAddress((unsigned char *)"glXGetMscRateOML");
|
|
|
++ glXSwapBuffersMscOML = (void *)glXGetProcAddress((unsigned char *)"glXSwapBuffersMscOML");
|
|
|
++ glXWaitForMscOML = (void *)glXGetProcAddress((unsigned char *)"glXWaitForMscOML");
|
|
|
++ glXWaitForSbcOML = (void *)glXGetProcAddress((unsigned char *)"glXWaitForSbcOML");
|
|
|
++ glXSwapInterval = (void *)glXGetProcAddress((unsigned char *)"glXSwapIntervalMESA");
|
|
|
++
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glXSwapInterval(swap_interval);
|
|
|
++ fprintf(stderr, "set swap interval to %d\n", swap_interval);
|
|
|
++
|
|
|
++ glXGetSyncValuesOML(disp, winGL, &ust, &msc, &sbc);
|
|
|
++ while (i++) {
|
|
|
++ /* Alternate colors to make tearing obvious */
|
|
|
++ if (i & 1) {
|
|
|
++ glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
++ glColor3f(1.0f, 1.0f, 1.0f);
|
|
|
++ } else {
|
|
|
++ glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
|
|
|
++ glColor3f(1.0f, 0.0f, 0.0f);
|
|
|
++ }
|
|
|
++
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++ glRectf(0, 0, width, height);
|
|
|
++
|
|
|
++ glXSwapBuffersMscOML(disp, winGL, 0, divisor, remainder);
|
|
|
++
|
|
|
++ if (wait_interval) {
|
|
|
++ glXWaitForMscOML(disp, winGL, msc + wait_interval,
|
|
|
++ 0, 0, &ust, &msc, &sbc);
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ XDestroyWindow(disp, winGL);
|
|
|
++ glXDestroyContext(disp, context);
|
|
|
++ XCloseDisplay(disp);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/opencloseopen.c Mesa-7.8.1.patched/progs/xdemos/opencloseopen.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/opencloseopen.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/opencloseopen.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,189 @@
|
|
|
++/*
|
|
|
++ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
|
|
|
++ * (C) Copyright IBM Corporation 2003
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++#include <stdlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++/** \file opencloseopen.c
|
|
|
++ * Simple test for Mesa bug #508473. Create a window and rendering context.
|
|
|
++ * Draw a single frame. Close the window, destroy the context, and close
|
|
|
++ * the display. Re-open the display, create a new window and context. This
|
|
|
++ * should work, but, at least as of Mesa 5.1, it segfaults. See the bug
|
|
|
++ * report for more details.
|
|
|
++ *
|
|
|
++ * Most of the code here was lifed from various other Mesa xdemos.
|
|
|
++ */
|
|
|
++
|
|
|
++static void
|
|
|
++draw(void)
|
|
|
++{
|
|
|
++ glViewport(0, 0, 300, 300);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++ glClearColor(0.5, 0.5, 0.5, 1.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++
|
|
|
++ /* draw blue quad */
|
|
|
++ glLoadIdentity();
|
|
|
++ glColor3f(0.3, 0.3, 1.0);
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(0, 0, 0, 1);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex2f(-0.5, -0.25);
|
|
|
++ glVertex2f( 0.5, -0.25);
|
|
|
++ glVertex2f( 0.5, 0.25);
|
|
|
++ glVertex2f(-0.5, 0.25);
|
|
|
++ glEnd();
|
|
|
++ glPopMatrix();}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window( const char * dpyName, const char *name,
|
|
|
++ int x, int y, int width, int height,
|
|
|
++ Display **dpyRet, Window *winRet, GLXContext *ctxRet)
|
|
|
++{
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ Display *dpy;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n", XDisplayName(dpyName));
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ *dpyRet = dpy;
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attrib );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(visinfo);
|
|
|
++
|
|
|
++ *winRet = win;
|
|
|
++ *ctxRet = ctx;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++destroy_window( Display *dpy, Window win, GLXContext ctx )
|
|
|
++{
|
|
|
++ glXMakeCurrent(dpy, None, NULL);
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ char *dpyName = NULL;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ printf("If this program segfaults, then Mesa bug #508473 is probably "
|
|
|
++ "back.\n");
|
|
|
++ make_window(dpyName, "Open-close-open", 0, 0, 300, 300, &dpy, &win, &ctx);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ glXMakeCurrent(dpy, win, ctx);
|
|
|
++
|
|
|
++ draw();
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++ sleep(2);
|
|
|
++
|
|
|
++ destroy_window(dpy, win, ctx);
|
|
|
++
|
|
|
++ make_window(dpyName, "Open-close-open", 0, 0, 300, 300, &dpy, &win, &ctx);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ glXMakeCurrent(dpy, win, ctx);
|
|
|
++ destroy_window(dpy, win, ctx);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/overlay.c Mesa-7.8.1.patched/progs/xdemos/overlay.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/overlay.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/overlay.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,246 @@
|
|
|
++/*
|
|
|
++ * GLX overlay test/demo.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * 18 July 2005
|
|
|
++ */
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <assert.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++
|
|
|
++static int WinWidth = 300, WinHeight = 300;
|
|
|
++static Window NormalWindow = 0;
|
|
|
++static Window OverlayWindow = 0;
|
|
|
++static GLXContext NormalContext = 0;
|
|
|
++static GLXContext OverlayContext = 0;
|
|
|
++static GLboolean RGBOverlay = GL_FALSE;
|
|
|
++static GLfloat Angle = 0.0;
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++RedrawNormal(Display *dpy)
|
|
|
++{
|
|
|
++ glXMakeCurrent(dpy, NormalWindow, NormalContext);
|
|
|
++ glViewport(0, 0, WinWidth, WinHeight);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glClearColor(0.5, 0.5, 0.5, 1.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++ glColor3f(1.0, 1.0, 0.0);
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(Angle, 0, 0, 1);
|
|
|
++ glRectf(-0.8, -0.8, 0.8, 0.8);
|
|
|
++ glPopMatrix();
|
|
|
++ glXSwapBuffers(dpy, NormalWindow);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++RedrawOverlay(Display *dpy)
|
|
|
++{
|
|
|
++ glXMakeCurrent(dpy, OverlayWindow, OverlayContext);
|
|
|
++ glViewport(0, 0, WinWidth, WinHeight);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++ if (RGBOverlay) {
|
|
|
++ glColor3f(0.0, 1.0, 1.0);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glIndexi(2);
|
|
|
++ }
|
|
|
++ glBegin(GL_LINES);
|
|
|
++ glVertex2f(-1, -1);
|
|
|
++ glVertex2f(1, 1);
|
|
|
++ glVertex2f(1, -1);
|
|
|
++ glVertex2f(-1, 1);
|
|
|
++ glEnd();
|
|
|
++ glXSwapBuffers(dpy, OverlayWindow);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static Window
|
|
|
++MakeWindow(Display *dpy, XVisualInfo *visinfo, Window parent,
|
|
|
++ unsigned int width, unsigned int height)
|
|
|
++{
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(dpy);
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow(dpy, parent, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++MakeNormalWindow(Display *dpy)
|
|
|
++{
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ Window root;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(dpy);
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attrib);
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ NormalWindow = MakeWindow(dpy, visinfo, root, WinWidth, WinHeight);
|
|
|
++ assert(NormalWindow);
|
|
|
++
|
|
|
++ NormalContext = glXCreateContext(dpy, visinfo, NULL, True);
|
|
|
++ assert(NormalContext);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++MakeOverlayWindow(Display *dpy)
|
|
|
++{
|
|
|
++ int rgbAttribs[] = {
|
|
|
++ GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_LEVEL, 1,
|
|
|
++ None
|
|
|
++ };
|
|
|
++ int indexAttribs[] = {
|
|
|
++ /*GLX_RGBA, leave this out */
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_LEVEL, 1,
|
|
|
++ None
|
|
|
++ };
|
|
|
++ int scrnum;
|
|
|
++ Window root;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(dpy);
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, rgbAttribs);
|
|
|
++ if (visinfo) {
|
|
|
++ printf("Found RGB overlay visual 0x%x\n", (int) visinfo->visualid);
|
|
|
++ RGBOverlay = GL_TRUE;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, indexAttribs);
|
|
|
++ if (visinfo) {
|
|
|
++ printf("Found Color Index overlay visual 0x%x\n",
|
|
|
++ (int) visinfo->visualid);
|
|
|
++ /* XXX setup the colormap entries! */
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Couldn't get an overlay visual.\n");
|
|
|
++ printf("Your hardware probably doesn't support framebuffer overlay planes.\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ OverlayWindow = MakeWindow(dpy, visinfo, NormalWindow, WinWidth, WinHeight);
|
|
|
++ assert(OverlayWindow);
|
|
|
++
|
|
|
++ OverlayContext = glXCreateContext(dpy, visinfo, NULL, True);
|
|
|
++ assert(OverlayContext);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++EventLoop(Display *dpy)
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ RedrawNormal(dpy);
|
|
|
++ RedrawOverlay(dpy);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ WinWidth = event.xconfigure.width;
|
|
|
++ WinHeight = event.xconfigure.height;
|
|
|
++ if (event.xconfigure.window == NormalWindow)
|
|
|
++ XResizeWindow(dpy, OverlayWindow, WinWidth, WinHeight);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ else if (buffer[0] == ' ') {
|
|
|
++ Angle += 5.0;
|
|
|
++ RedrawNormal(dpy);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ ; /* nothing */
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy = XOpenDisplay(NULL);
|
|
|
++
|
|
|
++ assert(dpy);
|
|
|
++
|
|
|
++ MakeNormalWindow(dpy);
|
|
|
++ MakeOverlayWindow(dpy);
|
|
|
++
|
|
|
++ XMapWindow(dpy, NormalWindow);
|
|
|
++ XMapWindow(dpy, OverlayWindow);
|
|
|
++
|
|
|
++ EventLoop(dpy);
|
|
|
++
|
|
|
++ glXDestroyContext(dpy, OverlayContext);
|
|
|
++ glXDestroyContext(dpy, NormalContext);
|
|
|
++ XDestroyWindow(dpy, OverlayWindow);
|
|
|
++ XDestroyWindow(dpy, NormalWindow);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/pbdemo.c Mesa-7.8.1.patched/progs/xdemos/pbdemo.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/pbdemo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/pbdemo.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,493 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * This program demonstrates how to do "off-screen" rendering using
|
|
|
++ * the GLX pixel buffer extension.
|
|
|
++ *
|
|
|
++ * Written by Brian Paul for the "OpenGL and Window System Integration"
|
|
|
++ * course presented at SIGGRAPH '97. Updated on 5 October 2002.
|
|
|
++ *
|
|
|
++ * Usage:
|
|
|
++ * pbuffers width height imgfile
|
|
|
++ * Where:
|
|
|
++ * width is the width, in pixels, of the image to generate.
|
|
|
++ * height is the height, in pixels, of the image to generate.
|
|
|
++ * imgfile is the name of the PPM image file to write.
|
|
|
++ *
|
|
|
++ *
|
|
|
++ * This demo draws 3-D boxes with random orientation. A pbuffer with
|
|
|
++ * a depth (Z) buffer is prefered but if such a pbuffer can't be created
|
|
|
++ * we use a non-depth-buffered config.
|
|
|
++ *
|
|
|
++ * On machines such as the SGI Indigo you may have to reconfigure your
|
|
|
++ * display/X server to enable pbuffers. Look in the /usr/gfx/ucode/MGRAS/vof/
|
|
|
++ * directory for display configurationswith the _pbuf suffix. Use
|
|
|
++ * setmon -x <vof> to configure your X server and display for pbuffers.
|
|
|
++ *
|
|
|
++ * O2 systems seem to support pbuffers well.
|
|
|
++ *
|
|
|
++ * IR systems (at least 1RM systems) don't have single-buffered, RGBA,
|
|
|
++ * Z-buffered pbuffer configs. BUT, they DO have DOUBLE-buffered, RGBA,
|
|
|
++ * Z-buffered pbuffers. Note how we try four different fbconfig attribute
|
|
|
++ * lists below!
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <assert.h>
|
|
|
++#include <string.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include "pbutil.h"
|
|
|
++
|
|
|
++
|
|
|
++/* Some ugly global vars */
|
|
|
++static Display *gDpy = NULL;
|
|
|
++static int gScreen = 0;
|
|
|
++static FBCONFIG gFBconfig = 0;
|
|
|
++static PBUFFER gPBuffer = 0;
|
|
|
++static int gWidth, gHeight;
|
|
|
++static GLXContext glCtx;
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create the pbuffer and return a GLXPbuffer handle.
|
|
|
++ *
|
|
|
++ * We loop over a list of fbconfigs trying to create
|
|
|
++ * a pixel buffer. We return the first pixel buffer which we successfully
|
|
|
++ * create.
|
|
|
++ */
|
|
|
++static PBUFFER
|
|
|
++MakePbuffer( Display *dpy, int screen, int width, int height )
|
|
|
++{
|
|
|
++#define NUM_FB_CONFIGS 4
|
|
|
++ const char fbString[NUM_FB_CONFIGS][100] = {
|
|
|
++ "Single Buffered, depth buffer",
|
|
|
++ "Double Buffered, depth buffer",
|
|
|
++ "Single Buffered, no depth buffer",
|
|
|
++ "Double Buffered, no depth buffer"
|
|
|
++ };
|
|
|
++ int fbAttribs[NUM_FB_CONFIGS][100] = {
|
|
|
++ {
|
|
|
++ /* Single buffered, with depth buffer */
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER, 0,
|
|
|
++ GLX_STENCIL_SIZE, 0,
|
|
|
++ None
|
|
|
++ },
|
|
|
++ {
|
|
|
++ /* Double buffered, with depth buffer */
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER, 1,
|
|
|
++ GLX_STENCIL_SIZE, 0,
|
|
|
++ None
|
|
|
++ },
|
|
|
++ {
|
|
|
++ /* Single buffered, without depth buffer */
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DEPTH_SIZE, 0,
|
|
|
++ GLX_DOUBLEBUFFER, 0,
|
|
|
++ GLX_STENCIL_SIZE, 0,
|
|
|
++ None
|
|
|
++ },
|
|
|
++ {
|
|
|
++ /* Double buffered, without depth buffer */
|
|
|
++ GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
++ GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DEPTH_SIZE, 0,
|
|
|
++ GLX_DOUBLEBUFFER, 1,
|
|
|
++ GLX_STENCIL_SIZE, 0,
|
|
|
++ None
|
|
|
++ }
|
|
|
++ };
|
|
|
++ Bool largest = True;
|
|
|
++ Bool preserve = False;
|
|
|
++ FBCONFIG *fbConfigs;
|
|
|
++ PBUFFER pBuffer = None;
|
|
|
++ int nConfigs;
|
|
|
++ int i;
|
|
|
++ int attempt;
|
|
|
++
|
|
|
++ for (attempt=0; attempt<NUM_FB_CONFIGS; attempt++) {
|
|
|
++
|
|
|
++ /* Get list of possible frame buffer configurations */
|
|
|
++ fbConfigs = ChooseFBConfig(dpy, screen, fbAttribs[attempt], &nConfigs);
|
|
|
++ if (nConfigs==0 || !fbConfigs) {
|
|
|
++ printf("Note: glXChooseFBConfig(%s) failed\n", fbString[attempt]);
|
|
|
++ XFree(fbConfigs);
|
|
|
++ continue;
|
|
|
++ }
|
|
|
++
|
|
|
++#if 0 /*DEBUG*/
|
|
|
++ for (i=0;i<nConfigs;i++) {
|
|
|
++ printf("Config %d\n", i);
|
|
|
++ PrintFBConfigInfo(dpy, screen, fbConfigs[i], 0);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* Create the pbuffer using first fbConfig in the list that works. */
|
|
|
++ for (i=0;i<nConfigs;i++) {
|
|
|
++ pBuffer = CreatePbuffer(dpy, screen, fbConfigs[i], width, height, largest, preserve);
|
|
|
++ if (pBuffer) {
|
|
|
++ gFBconfig = fbConfigs[i];
|
|
|
++ gWidth = width;
|
|
|
++ gHeight = height;
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if (pBuffer!=None) {
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if (pBuffer) {
|
|
|
++ printf("Using: %s\n", fbString[attempt]);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(fbConfigs);
|
|
|
++
|
|
|
++ return pBuffer;
|
|
|
++#undef NUM_FB_CONFIGS
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Do all the X / GLX setup stuff.
|
|
|
++ */
|
|
|
++static int
|
|
|
++Setup(int width, int height)
|
|
|
++{
|
|
|
++ int pbSupport;
|
|
|
++ XVisualInfo *visInfo;
|
|
|
++
|
|
|
++ /* Open the X display */
|
|
|
++ gDpy = XOpenDisplay(NULL);
|
|
|
++ if (!gDpy) {
|
|
|
++ printf("Error: couldn't open default X display.\n");
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Get default screen */
|
|
|
++ gScreen = DefaultScreen(gDpy);
|
|
|
++
|
|
|
++ /* Test that pbuffers are available */
|
|
|
++ pbSupport = QueryPbuffers(gDpy, gScreen);
|
|
|
++ if (pbSupport == 1) {
|
|
|
++ printf("Using GLX 1.3 Pbuffers\n");
|
|
|
++ }
|
|
|
++ else if (pbSupport == 2) {
|
|
|
++ printf("Using SGIX Pbuffers\n");
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Error: pbuffers not available on this screen\n");
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Create Pbuffer */
|
|
|
++ gPBuffer = MakePbuffer( gDpy, gScreen, width, height );
|
|
|
++ if (gPBuffer==None) {
|
|
|
++ printf("Error: couldn't create pbuffer\n");
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Test drawable queries */
|
|
|
++ {
|
|
|
++ unsigned int v;
|
|
|
++ glXQueryDrawable( gDpy, gPBuffer, GLX_WIDTH, &v);
|
|
|
++ printf("GLX_WIDTH = %u\n", v);
|
|
|
++ glXQueryDrawable( gDpy, gPBuffer, GLX_HEIGHT, &v);
|
|
|
++ printf("GLX_HEIGHT = %u\n", v);
|
|
|
++ glXQueryDrawable( gDpy, gPBuffer, GLX_PRESERVED_CONTENTS, &v);
|
|
|
++ printf("GLX_PRESERVED_CONTENTS = %u\n", v);
|
|
|
++ glXQueryDrawable( gDpy, gPBuffer, GLX_LARGEST_PBUFFER, &v);
|
|
|
++ printf("GLX_LARGEST_PBUFFER = %u\n", v);
|
|
|
++ glXQueryDrawable( gDpy, gPBuffer, GLX_FBCONFIG_ID, &v);
|
|
|
++ printf("GLX_FBCONFIG_ID = %u\n", v);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Get corresponding XVisualInfo */
|
|
|
++ visInfo = GetVisualFromFBConfig(gDpy, gScreen, gFBconfig);
|
|
|
++ if (!visInfo) {
|
|
|
++ printf("Error: can't get XVisualInfo from FBconfig\n");
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Create GLX context */
|
|
|
++ glCtx = glXCreateContext(gDpy, visInfo, NULL, True);
|
|
|
++ if (!glCtx) {
|
|
|
++ /* try indirect */
|
|
|
++ glCtx = glXCreateContext(gDpy, visInfo, NULL, False);
|
|
|
++ if (!glCtx) {
|
|
|
++ printf("Error: Couldn't create GLXContext\n");
|
|
|
++ XFree(visInfo);
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Warning: using indirect GLXContext\n");
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Bind context to pbuffer */
|
|
|
++ if (!glXMakeCurrent(gDpy, gPBuffer, glCtx)) {
|
|
|
++ printf("Error: glXMakeCurrent failed\n");
|
|
|
++ XFree(visInfo);
|
|
|
++ XCloseDisplay(gDpy);
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ return 1; /* Success!! */
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/* One-time GL setup */
|
|
|
++static void
|
|
|
++InitGL(void)
|
|
|
++{
|
|
|
++ static GLfloat pos[4] = {0.0, 0.0, 10.0, 0.0};
|
|
|
++ glEnable(GL_LIGHTING);
|
|
|
++ glEnable(GL_LIGHT0);
|
|
|
++ glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
|
++ glEnable(GL_NORMALIZE);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++ glEnable(GL_CULL_FACE);
|
|
|
++
|
|
|
++ glViewport(0, 0, gWidth, gHeight);
|
|
|
++ glMatrixMode( GL_PROJECTION );
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 );
|
|
|
++ glMatrixMode( GL_MODELVIEW );
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef( 0.0, 0.0, -15.0 );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* Return random float in [0,1] */
|
|
|
++static float
|
|
|
++Random(void)
|
|
|
++{
|
|
|
++ int i = rand();
|
|
|
++ return (float) (i % 1000) / 1000.0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++RandomColor(void)
|
|
|
++{
|
|
|
++ GLfloat c[4];
|
|
|
++ c[0] = Random();
|
|
|
++ c[1] = Random();
|
|
|
++ c[2] = Random();
|
|
|
++ c[3] = 1.0;
|
|
|
++ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, c);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* This function borrowed from Mark Kilgard's GLUT */
|
|
|
++static void
|
|
|
++drawBox(GLfloat x0, GLfloat x1, GLfloat y0, GLfloat y1,
|
|
|
++ GLfloat z0, GLfloat z1, GLenum type)
|
|
|
++{
|
|
|
++ static GLfloat n[6][3] =
|
|
|
++ {
|
|
|
++ {-1.0, 0.0, 0.0},
|
|
|
++ {0.0, 1.0, 0.0},
|
|
|
++ {1.0, 0.0, 0.0},
|
|
|
++ {0.0, -1.0, 0.0},
|
|
|
++ {0.0, 0.0, 1.0},
|
|
|
++ {0.0, 0.0, -1.0}
|
|
|
++ };
|
|
|
++ static GLint faces[6][4] =
|
|
|
++ {
|
|
|
++ {0, 1, 2, 3},
|
|
|
++ {3, 2, 6, 7},
|
|
|
++ {7, 6, 5, 4},
|
|
|
++ {4, 5, 1, 0},
|
|
|
++ {5, 6, 2, 1},
|
|
|
++ {7, 4, 0, 3}
|
|
|
++ };
|
|
|
++ GLfloat v[8][3], tmp;
|
|
|
++ GLint i;
|
|
|
++
|
|
|
++ if (x0 > x1) {
|
|
|
++ tmp = x0;
|
|
|
++ x0 = x1;
|
|
|
++ x1 = tmp;
|
|
|
++ }
|
|
|
++ if (y0 > y1) {
|
|
|
++ tmp = y0;
|
|
|
++ y0 = y1;
|
|
|
++ y1 = tmp;
|
|
|
++ }
|
|
|
++ if (z0 > z1) {
|
|
|
++ tmp = z0;
|
|
|
++ z0 = z1;
|
|
|
++ z1 = tmp;
|
|
|
++ }
|
|
|
++ v[0][0] = v[1][0] = v[2][0] = v[3][0] = x0;
|
|
|
++ v[4][0] = v[5][0] = v[6][0] = v[7][0] = x1;
|
|
|
++ v[0][1] = v[1][1] = v[4][1] = v[5][1] = y0;
|
|
|
++ v[2][1] = v[3][1] = v[6][1] = v[7][1] = y1;
|
|
|
++ v[0][2] = v[3][2] = v[4][2] = v[7][2] = z0;
|
|
|
++ v[1][2] = v[2][2] = v[5][2] = v[6][2] = z1;
|
|
|
++
|
|
|
++ for (i = 0; i < 6; i++) {
|
|
|
++ glBegin(type);
|
|
|
++ glNormal3fv(&n[i][0]);
|
|
|
++ glVertex3fv(&v[faces[i][0]][0]);
|
|
|
++ glVertex3fv(&v[faces[i][1]][0]);
|
|
|
++ glVertex3fv(&v[faces[i][2]][0]);
|
|
|
++ glVertex3fv(&v[faces[i][3]][0]);
|
|
|
++ glEnd();
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/* Render a scene */
|
|
|
++static void
|
|
|
++Render(void)
|
|
|
++{
|
|
|
++ int NumBoxes = 100;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ glClearColor(0.2, 0.2, 0.9, 0.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ for (i=0;i<NumBoxes;i++) {
|
|
|
++ float tx = -2.0 + 4.0 * Random();
|
|
|
++ float ty = -2.0 + 4.0 * Random();
|
|
|
++ float tz = 4.0 - 16.0 * Random();
|
|
|
++ float sx = 0.1 + Random() * 0.4;
|
|
|
++ float sy = 0.1 + Random() * 0.4;
|
|
|
++ float sz = 0.1 + Random() * 0.4;
|
|
|
++ float rx = Random();
|
|
|
++ float ry = Random();
|
|
|
++ float rz = Random();
|
|
|
++ float ra = Random() * 360.0;
|
|
|
++ glPushMatrix();
|
|
|
++ glTranslatef(tx, ty, tz);
|
|
|
++ glRotatef(ra, rx, ry, rz);
|
|
|
++ glScalef(sx, sy, sz);
|
|
|
++ RandomColor();
|
|
|
++ drawBox(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0, GL_POLYGON);
|
|
|
++ glPopMatrix();
|
|
|
++ }
|
|
|
++
|
|
|
++ glFinish();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++WriteFile(const char *filename)
|
|
|
++{
|
|
|
++ FILE *f;
|
|
|
++ GLubyte *image;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ image = malloc(gWidth * gHeight * 3 * sizeof(GLubyte));
|
|
|
++ if (!image) {
|
|
|
++ printf("Error: couldn't allocate image buffer\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
|
++ glReadPixels(0, 0, gWidth, gHeight, GL_RGB, GL_UNSIGNED_BYTE, image);
|
|
|
++
|
|
|
++ f = fopen(filename, "w");
|
|
|
++ if (!f) {
|
|
|
++ printf("Couldn't open image file: %s\n", filename);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ fprintf(f,"P6\n");
|
|
|
++ fprintf(f,"# ppm-file created by %s\n", "trdemo2");
|
|
|
++ fprintf(f,"%i %i\n", gWidth, gHeight);
|
|
|
++ fprintf(f,"255\n");
|
|
|
++ fclose(f);
|
|
|
++ f = fopen(filename, "ab"); /* now append binary data */
|
|
|
++ if (!f) {
|
|
|
++ printf("Couldn't append to image file: %s\n", filename);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ for (i=0;i<gHeight;i++) {
|
|
|
++ GLubyte *rowPtr;
|
|
|
++ /* Remember, OpenGL images are bottom to top. Have to reverse. */
|
|
|
++ rowPtr = image + (gHeight-1-i) * gWidth*3;
|
|
|
++ fwrite(rowPtr, 1, gWidth*3, f);
|
|
|
++ }
|
|
|
++
|
|
|
++ fclose(f);
|
|
|
++ free(image);
|
|
|
++
|
|
|
++ printf("Wrote %d by %d image file: %s\n", gWidth, gHeight, filename);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Print message describing command line parameters.
|
|
|
++ */
|
|
|
++static void
|
|
|
++Usage(const char *appName)
|
|
|
++{
|
|
|
++ printf("Usage:\n");
|
|
|
++ printf(" %s width height imgfile\n", appName);
|
|
|
++ printf("Where imgfile is a ppm file\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ if (argc!=4) {
|
|
|
++ Usage(argv[0]);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ int width = atoi(argv[1]);
|
|
|
++ int height = atoi(argv[2]);
|
|
|
++ char *fileName = argv[3];
|
|
|
++ if (width<=0) {
|
|
|
++ printf("Error: width parameter must be at least 1.\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++ if (height<=0) {
|
|
|
++ printf("Error: height parameter must be at least 1.\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++ if (!Setup(width, height)) {
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++ InitGL();
|
|
|
++ Render();
|
|
|
++ WriteFile(fileName);
|
|
|
++ DestroyPbuffer(gDpy, gScreen, gPBuffer);
|
|
|
++ }
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/pbinfo.c Mesa-7.8.1.patched/progs/xdemos/pbinfo.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/pbinfo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/pbinfo.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,107 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * Print list of fbconfigs and test each to see if a pbuffer can be created
|
|
|
++ * for that config.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * April 1997
|
|
|
++ * Updated on 5 October 2002.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include "pbutil.h"
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++PrintConfigs(Display *dpy, int screen, Bool horizFormat)
|
|
|
++{
|
|
|
++ FBCONFIG *fbConfigs;
|
|
|
++ int nConfigs;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ fbConfigs = GetAllFBConfigs(dpy, screen, &nConfigs);
|
|
|
++ if (!nConfigs || !fbConfigs) {
|
|
|
++ printf("Error: glxGetFBConfigs failed\n");
|
|
|
++ XFree(fbConfigs);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ printf("Number of fbconfigs: %d\n", nConfigs);
|
|
|
++
|
|
|
++ if (horizFormat) {
|
|
|
++ printf(" ID VisualType Depth Lvl RGB CI DB Stereo R G B A");
|
|
|
++ printf(" Z S AR AG AB AA MSbufs MSnum Pbuffer Float\n");
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Print config info */
|
|
|
++ for (i = 0; i < nConfigs; i++) {
|
|
|
++ PrintFBConfigInfo(dpy, screen, fbConfigs[i], horizFormat);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* free the list */
|
|
|
++ XFree(fbConfigs);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++PrintUsage(void)
|
|
|
++{
|
|
|
++ printf("Options:\n");
|
|
|
++ printf(" -display <display-name> specify X display name\n");
|
|
|
++ printf(" -t print in tabular format\n");
|
|
|
++ printf(" -v print in verbose format\n");
|
|
|
++ printf(" -help print this information\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ int scrn;
|
|
|
++ char *dpyName = NULL;
|
|
|
++ Bool horizFormat = True;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i=1; i<argc; i++) {
|
|
|
++ if (strcmp(argv[i],"-display")==0) {
|
|
|
++ if (i+1<argc) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i],"-t")==0) {
|
|
|
++ /* tabular format */
|
|
|
++ horizFormat = True;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i],"-v")==0) {
|
|
|
++ /* verbose format */
|
|
|
++ horizFormat = False;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i],"-help")==0) {
|
|
|
++ PrintUsage();
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Unknown option: %s\n", argv[i]);
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n", XDisplayName(dpyName));
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++
|
|
|
++ scrn = DefaultScreen(dpy);
|
|
|
++ PrintConfigs(dpy, scrn, horizFormat);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/pbutil.c Mesa-7.8.1.patched/progs/xdemos/pbutil.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/pbutil.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/pbutil.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,446 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * OpenGL pbuffers utility functions.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * Original code: April 1997
|
|
|
++ * Updated on 5 October 2002
|
|
|
++ * Updated again on 3 January 2005 to use GLX 1.3 functions in preference
|
|
|
++ * to the GLX_SGIX_fbconfig/pbuffer extensions.
|
|
|
++ */
|
|
|
++
|
|
|
++#include <stdio.h>
|
|
|
++#include <string.h>
|
|
|
++#include "pbutil.h"
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Test if we pixel buffers are available for a particular X screen.
|
|
|
++ * Input: dpy - the X display
|
|
|
++ * screen - screen number
|
|
|
++ * Return: 0 = fbconfigs not available.
|
|
|
++ * 1 = fbconfigs are available via GLX 1.3.
|
|
|
++ * 2 = fbconfigs and pbuffers are available via GLX_SGIX_fbconfig
|
|
|
++ */
|
|
|
++int
|
|
|
++QueryFBConfig(Display *dpy, int screen)
|
|
|
++{
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ {
|
|
|
++ /* GLX 1.3 supports pbuffers */
|
|
|
++ int glxVersionMajor, glxVersionMinor;
|
|
|
++ if (!glXQueryVersion(dpy, &glxVersionMajor, &glxVersionMinor)) {
|
|
|
++ /* GLX not available! */
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ if (glxVersionMajor * 100 + glxVersionMinor >= 103) {
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++ /* fall-through */
|
|
|
++ }
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* Try the SGIX extensions */
|
|
|
++ {
|
|
|
++ char *extensions;
|
|
|
++ extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS);
|
|
|
++ if (extensions && strstr(extensions,"GLX_SGIX_fbconfig")) {
|
|
|
++ return 2;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++/**
|
|
|
++ * Test if we pixel buffers are available for a particular X screen.
|
|
|
++ * Input: dpy - the X display
|
|
|
++ * screen - screen number
|
|
|
++ * Return: 0 = pixel buffers not available.
|
|
|
++ * 1 = pixel buffers are available via GLX 1.3.
|
|
|
++ * 2 = pixel buffers are available via GLX_SGIX_fbconfig/pbuffer.
|
|
|
++ */
|
|
|
++int
|
|
|
++QueryPbuffers(Display *dpy, int screen)
|
|
|
++{
|
|
|
++ int ret;
|
|
|
++
|
|
|
++ ret = QueryFBConfig(dpy, screen);
|
|
|
++ if (ret == 2) {
|
|
|
++ char *extensions;
|
|
|
++ extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS);
|
|
|
++ if (extensions && strstr(extensions, "GLX_SGIX_pbuffer"))
|
|
|
++ return 2;
|
|
|
++ else
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++ else
|
|
|
++ return ret;
|
|
|
++}
|
|
|
++
|
|
|
++FBCONFIG *
|
|
|
++ChooseFBConfig(Display *dpy, int screen, const int attribs[], int *nConfigs)
|
|
|
++{
|
|
|
++ int fbcSupport = QueryPbuffers(dpy, screen);
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ if (fbcSupport == 1) {
|
|
|
++ return glXChooseFBConfig(dpy, screen, attribs, nConfigs);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++ if (fbcSupport == 2) {
|
|
|
++ return glXChooseFBConfigSGIX(dpy, screen, (int *) attribs, nConfigs);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++FBCONFIG *
|
|
|
++GetAllFBConfigs(Display *dpy, int screen, int *nConfigs)
|
|
|
++{
|
|
|
++ int fbcSupport = QueryFBConfig(dpy, screen);
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ if (fbcSupport == 1) {
|
|
|
++ return glXGetFBConfigs(dpy, screen, nConfigs);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++ if (fbcSupport == 2) {
|
|
|
++ /* The GLX_SGIX_fbconfig extensions says to pass NULL to get list
|
|
|
++ * of all available configurations.
|
|
|
++ */
|
|
|
++ return glXChooseFBConfigSGIX(dpy, screen, NULL, nConfigs);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++XVisualInfo *
|
|
|
++GetVisualFromFBConfig(Display *dpy, int screen, FBCONFIG config)
|
|
|
++{
|
|
|
++ int fbcSupport = QueryFBConfig(dpy, screen);
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ if (fbcSupport == 1) {
|
|
|
++ return glXGetVisualFromFBConfig(dpy, config);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++ if (fbcSupport == 2) {
|
|
|
++ return glXGetVisualFromFBConfigSGIX(dpy, config);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Either use glXGetFBConfigAttrib() or glXGetFBConfigAttribSGIX()
|
|
|
++ * to query an fbconfig attribute.
|
|
|
++ */
|
|
|
++static int
|
|
|
++GetFBConfigAttrib(Display *dpy, int screen,
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ const GLXFBConfig config,
|
|
|
++#elif defined(GLX_SGIX_fbconfig)
|
|
|
++ const GLXFBConfigSGIX config,
|
|
|
++#endif
|
|
|
++ int attrib
|
|
|
++ )
|
|
|
++{
|
|
|
++ int fbcSupport = QueryFBConfig(dpy, screen);
|
|
|
++ int value = 0;
|
|
|
++
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ if (fbcSupport == 1) {
|
|
|
++ /* ok */
|
|
|
++ if (glXGetFBConfigAttrib(dpy, config, attrib, &value) != 0) {
|
|
|
++ value = 0;
|
|
|
++ }
|
|
|
++ return value;
|
|
|
++ }
|
|
|
++ /* fall-through */
|
|
|
++#endif
|
|
|
++
|
|
|
++#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++ if (fbcSupport == 2) {
|
|
|
++ if (glXGetFBConfigAttribSGIX(dpy, config, attrib, &value) != 0) {
|
|
|
++ value = 0;
|
|
|
++ }
|
|
|
++ return value;
|
|
|
++ }
|
|
|
++#endif
|
|
|
++
|
|
|
++ return value;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Print parameters for a GLXFBConfig to stdout.
|
|
|
++ * Input: dpy - the X display
|
|
|
++ * screen - the X screen number
|
|
|
++ * fbConfig - the fbconfig handle
|
|
|
++ * horizFormat - if true, print in horizontal format
|
|
|
++ */
|
|
|
++void
|
|
|
++PrintFBConfigInfo(Display *dpy, int screen, FBCONFIG config, Bool horizFormat)
|
|
|
++{
|
|
|
++ PBUFFER pBuffer;
|
|
|
++ int width=2, height=2;
|
|
|
++ int bufferSize, level, doubleBuffer, stereo, auxBuffers;
|
|
|
++ int redSize, greenSize, blueSize, alphaSize;
|
|
|
++ int depthSize, stencilSize;
|
|
|
++ int accumRedSize, accumBlueSize, accumGreenSize, accumAlphaSize;
|
|
|
++ int sampleBuffers, samples;
|
|
|
++ int drawableType, renderType, xRenderable, xVisual, id;
|
|
|
++ int maxWidth, maxHeight, maxPixels;
|
|
|
++ int optWidth, optHeight;
|
|
|
++ int floatComponents = 0;
|
|
|
++
|
|
|
++ /* do queries using the GLX 1.3 tokens (same as the SGIX tokens) */
|
|
|
++ bufferSize = GetFBConfigAttrib(dpy, screen, config, GLX_BUFFER_SIZE);
|
|
|
++ level = GetFBConfigAttrib(dpy, screen, config, GLX_LEVEL);
|
|
|
++ doubleBuffer = GetFBConfigAttrib(dpy, screen, config, GLX_DOUBLEBUFFER);
|
|
|
++ stereo = GetFBConfigAttrib(dpy, screen, config, GLX_STEREO);
|
|
|
++ auxBuffers = GetFBConfigAttrib(dpy, screen, config, GLX_AUX_BUFFERS);
|
|
|
++ redSize = GetFBConfigAttrib(dpy, screen, config, GLX_RED_SIZE);
|
|
|
++ greenSize = GetFBConfigAttrib(dpy, screen, config, GLX_GREEN_SIZE);
|
|
|
++ blueSize = GetFBConfigAttrib(dpy, screen, config, GLX_BLUE_SIZE);
|
|
|
++ alphaSize = GetFBConfigAttrib(dpy, screen, config, GLX_ALPHA_SIZE);
|
|
|
++ depthSize = GetFBConfigAttrib(dpy, screen, config, GLX_DEPTH_SIZE);
|
|
|
++ stencilSize = GetFBConfigAttrib(dpy, screen, config, GLX_STENCIL_SIZE);
|
|
|
++ accumRedSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_RED_SIZE);
|
|
|
++ accumGreenSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_GREEN_SIZE);
|
|
|
++ accumBlueSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_BLUE_SIZE);
|
|
|
++ accumAlphaSize = GetFBConfigAttrib(dpy, screen, config, GLX_ACCUM_ALPHA_SIZE);
|
|
|
++ sampleBuffers = GetFBConfigAttrib(dpy, screen, config, GLX_SAMPLE_BUFFERS);
|
|
|
++ samples = GetFBConfigAttrib(dpy, screen, config, GLX_SAMPLES);
|
|
|
++ drawableType = GetFBConfigAttrib(dpy, screen, config, GLX_DRAWABLE_TYPE);
|
|
|
++ renderType = GetFBConfigAttrib(dpy, screen, config, GLX_RENDER_TYPE);
|
|
|
++ xRenderable = GetFBConfigAttrib(dpy, screen, config, GLX_X_RENDERABLE);
|
|
|
++ xVisual = GetFBConfigAttrib(dpy, screen, config, GLX_X_VISUAL_TYPE);
|
|
|
++ if (!xRenderable || !(drawableType & GLX_WINDOW_BIT_SGIX))
|
|
|
++ xVisual = -1;
|
|
|
++
|
|
|
++ id = GetFBConfigAttrib(dpy, screen, config, GLX_FBCONFIG_ID);
|
|
|
++ maxWidth = GetFBConfigAttrib(dpy, screen, config, GLX_MAX_PBUFFER_WIDTH);
|
|
|
++ maxHeight = GetFBConfigAttrib(dpy, screen, config, GLX_MAX_PBUFFER_HEIGHT);
|
|
|
++ maxPixels = GetFBConfigAttrib(dpy, screen, config, GLX_MAX_PBUFFER_PIXELS);
|
|
|
++#if defined(GLX_SGIX_pbuffer)
|
|
|
++ optWidth = GetFBConfigAttrib(dpy, screen, config, GLX_OPTIMAL_PBUFFER_WIDTH_SGIX);
|
|
|
++ optHeight = GetFBConfigAttrib(dpy, screen, config, GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX);
|
|
|
++#else
|
|
|
++ optWidth = optHeight = 0;
|
|
|
++#endif
|
|
|
++#if defined(GLX_NV_float_buffer)
|
|
|
++ floatComponents = GetFBConfigAttrib(dpy, screen, config, GLX_FLOAT_COMPONENTS_NV);
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* See if we can create a pbuffer with this config */
|
|
|
++ pBuffer = CreatePbuffer(dpy, screen, config, width, height, False, False);
|
|
|
++
|
|
|
++ if (horizFormat) {
|
|
|
++ printf("0x%-9x ", id);
|
|
|
++ if (xVisual==GLX_STATIC_GRAY) printf("StaticGray ");
|
|
|
++ else if (xVisual==GLX_GRAY_SCALE) printf("GrayScale ");
|
|
|
++ else if (xVisual==GLX_STATIC_COLOR) printf("StaticColor ");
|
|
|
++ else if (xVisual==GLX_PSEUDO_COLOR) printf("PseudoColor ");
|
|
|
++ else if (xVisual==GLX_TRUE_COLOR) printf("TrueColor ");
|
|
|
++ else if (xVisual==GLX_DIRECT_COLOR) printf("DirectColor ");
|
|
|
++ else printf(" -none- ");
|
|
|
++ printf(" %3d %3d %s %s %s %2s ", bufferSize, level,
|
|
|
++ (renderType & GLX_RGBA_BIT_SGIX) ? "y" : ".",
|
|
|
++ (renderType & GLX_COLOR_INDEX_BIT_SGIX) ? "y" : ".",
|
|
|
++ doubleBuffer ? "y" : ".",
|
|
|
++ stereo ? "y" : ".");
|
|
|
++ printf("%2d %2d %2d %2d ", redSize, greenSize, blueSize, alphaSize);
|
|
|
++ printf("%2d %2d ", depthSize, stencilSize);
|
|
|
++ printf("%2d %2d %2d %2d", accumRedSize, accumGreenSize, accumBlueSize,
|
|
|
++ accumAlphaSize);
|
|
|
++ printf(" %2d %2d", sampleBuffers, samples);
|
|
|
++ printf(" %s %c", pBuffer ? "y" : ".",
|
|
|
++ ".y"[floatComponents]);
|
|
|
++ printf("\n");
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ printf("Id 0x%x\n", id);
|
|
|
++ printf(" Buffer Size: %d\n", bufferSize);
|
|
|
++ printf(" Level: %d\n", level);
|
|
|
++ printf(" Double Buffer: %s\n", doubleBuffer ? "yes" : "no");
|
|
|
++ printf(" Stereo: %s\n", stereo ? "yes" : "no");
|
|
|
++ printf(" Aux Buffers: %d\n", auxBuffers);
|
|
|
++ printf(" Red Size: %d\n", redSize);
|
|
|
++ printf(" Green Size: %d\n", greenSize);
|
|
|
++ printf(" Blue Size: %d\n", blueSize);
|
|
|
++ printf(" Alpha Size: %d\n", alphaSize);
|
|
|
++ printf(" Depth Size: %d\n", depthSize);
|
|
|
++ printf(" Stencil Size: %d\n", stencilSize);
|
|
|
++ printf(" Accum Red Size: %d\n", accumRedSize);
|
|
|
++ printf(" Accum Green Size: %d\n", accumGreenSize);
|
|
|
++ printf(" Accum Blue Size: %d\n", accumBlueSize);
|
|
|
++ printf(" Accum Alpha Size: %d\n", accumAlphaSize);
|
|
|
++ printf(" Sample Buffers: %d\n", sampleBuffers);
|
|
|
++ printf(" Samples/Pixel: %d\n", samples);
|
|
|
++ printf(" Drawable Types: ");
|
|
|
++ if (drawableType & GLX_WINDOW_BIT) printf("Window ");
|
|
|
++ if (drawableType & GLX_PIXMAP_BIT) printf("Pixmap ");
|
|
|
++ if (drawableType & GLX_PBUFFER_BIT) printf("PBuffer");
|
|
|
++ printf("\n");
|
|
|
++ printf(" Render Types: ");
|
|
|
++ if (renderType & GLX_RGBA_BIT_SGIX) printf("RGBA ");
|
|
|
++ if (renderType & GLX_COLOR_INDEX_BIT_SGIX) printf("CI ");
|
|
|
++ printf("\n");
|
|
|
++ printf(" X Renderable: %s\n", xRenderable ? "yes" : "no");
|
|
|
++
|
|
|
++ printf(" Pbuffer: %s\n", pBuffer ? "yes" : "no");
|
|
|
++ printf(" Max Pbuffer width: %d\n", maxWidth);
|
|
|
++ printf(" Max Pbuffer height: %d\n", maxHeight);
|
|
|
++ printf(" Max Pbuffer pixels: %d\n", maxPixels);
|
|
|
++ printf(" Optimum Pbuffer width: %d\n", optWidth);
|
|
|
++ printf(" Optimum Pbuffer height: %d\n", optHeight);
|
|
|
++
|
|
|
++ printf(" Float Components: %s\n", floatComponents ? "yes" : "no");
|
|
|
++ }
|
|
|
++
|
|
|
++ if (pBuffer) {
|
|
|
++ DestroyPbuffer(dpy, screen, pBuffer);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++GLXContext
|
|
|
++CreateContext(Display *dpy, int screen, FBCONFIG config)
|
|
|
++{
|
|
|
++ int fbcSupport = QueryFBConfig(dpy, screen);
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ if (fbcSupport == 1) {
|
|
|
++ /* GLX 1.3 */
|
|
|
++ GLXContext c;
|
|
|
++ c = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE, NULL, True);
|
|
|
++ if (!c) {
|
|
|
++ /* try indirect */
|
|
|
++ c = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE, NULL, False);
|
|
|
++ }
|
|
|
++ return c;
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++ if (fbcSupport == 2) {
|
|
|
++ GLXContext c;
|
|
|
++ c = glXCreateContextWithConfigSGIX(dpy, config, GLX_RGBA_TYPE_SGIX, NULL, True);
|
|
|
++ if (!c) {
|
|
|
++ c = glXCreateContextWithConfigSGIX(dpy, config, GLX_RGBA_TYPE_SGIX, NULL, False);
|
|
|
++ }
|
|
|
++ return c;
|
|
|
++ }
|
|
|
++#endif
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void
|
|
|
++DestroyContext(Display *dpy, GLXContext ctx)
|
|
|
++{
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* This is only used by CreatePbuffer() */
|
|
|
++static int XErrorFlag = 0;
|
|
|
++static int HandleXError(Display *dpy, XErrorEvent *event)
|
|
|
++{
|
|
|
++ XErrorFlag = 1;
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Create a Pbuffer. Use an X error handler to deal with potential
|
|
|
++ * BadAlloc errors.
|
|
|
++ *
|
|
|
++ * Input: dpy - the X display
|
|
|
++ * fbConfig - an FBConfig as returned by glXChooseFBConfigSGIX().
|
|
|
++ * width, height - size of pixel buffer to request, in pixels.
|
|
|
++ * pbAttribs - list of optional pixel buffer attributes
|
|
|
++ * Return: a Pbuffer or None.
|
|
|
++ */
|
|
|
++PBUFFER
|
|
|
++CreatePbuffer(Display *dpy, int screen, FBCONFIG config,
|
|
|
++ int width, int height, Bool largest, Bool preserve)
|
|
|
++{
|
|
|
++ int (*oldHandler)(Display *, XErrorEvent *);
|
|
|
++ PBUFFER pBuffer = None;
|
|
|
++ int pbSupport = QueryPbuffers(dpy, screen);
|
|
|
++
|
|
|
++ /* Catch X protocol errors with our own error handler */
|
|
|
++ oldHandler = XSetErrorHandler(HandleXError);
|
|
|
++ XErrorFlag = 0;
|
|
|
++
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ if (pbSupport == 1) {
|
|
|
++ /* GLX 1.3 */
|
|
|
++ int attribs[100], i = 0;
|
|
|
++ attribs[i++] = GLX_PBUFFER_WIDTH;
|
|
|
++ attribs[i++] = width;
|
|
|
++ attribs[i++] = GLX_PBUFFER_HEIGHT;
|
|
|
++ attribs[i++] = height;
|
|
|
++ attribs[i++] = GLX_PRESERVED_CONTENTS;
|
|
|
++ attribs[i++] = preserve;
|
|
|
++ attribs[i++] = GLX_LARGEST_PBUFFER;
|
|
|
++ attribs[i++] = largest;
|
|
|
++ attribs[i++] = 0;
|
|
|
++ pBuffer = glXCreatePbuffer(dpy, config, attribs);
|
|
|
++ }
|
|
|
++ else
|
|
|
++#endif
|
|
|
++#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++ if (pbSupport == 2) {
|
|
|
++ int attribs[100], i = 0;
|
|
|
++ attribs[i++] = GLX_PRESERVED_CONTENTS;
|
|
|
++ attribs[i++] = preserve;
|
|
|
++ attribs[i++] = GLX_LARGEST_PBUFFER;
|
|
|
++ attribs[i++] = largest;
|
|
|
++ attribs[i++] = 0;
|
|
|
++ pBuffer = glXCreateGLXPbufferSGIX(dpy, config, width, height, attribs);
|
|
|
++ }
|
|
|
++ else
|
|
|
++#endif
|
|
|
++ {
|
|
|
++ pBuffer = None;
|
|
|
++ }
|
|
|
++
|
|
|
++ XSync(dpy, False);
|
|
|
++ /* Restore original X error handler */
|
|
|
++ (void) XSetErrorHandler(oldHandler);
|
|
|
++
|
|
|
++ /* Return pbuffer (may be None) */
|
|
|
++ if (!XErrorFlag && pBuffer != None) {
|
|
|
++ /*printf("config %d worked!\n", i);*/
|
|
|
++ return pBuffer;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ return None;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void
|
|
|
++DestroyPbuffer(Display *dpy, int screen, PBUFFER pbuffer)
|
|
|
++{
|
|
|
++ int pbSupport = QueryPbuffers(dpy, screen);
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++ if (pbSupport == 1) {
|
|
|
++ glXDestroyPbuffer(dpy, pbuffer);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++#endif
|
|
|
++#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++ if (pbSupport == 2) {
|
|
|
++ glXDestroyGLXPbufferSGIX(dpy, pbuffer);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++#endif
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/pbutil.h Mesa-7.8.1.patched/progs/xdemos/pbutil.h
|
|
|
+--- Mesa-7.8.1/progs/xdemos/pbutil.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/pbutil.h 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,69 @@
|
|
|
++/*
|
|
|
++ * OpenGL pbuffers utility functions.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * April 1997
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#ifndef PBUTIL_H
|
|
|
++#define PBUTIL_H
|
|
|
++
|
|
|
++
|
|
|
++#define GLX_GLXEXT_PROTOTYPES
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++
|
|
|
++#if defined(GLX_VERSION_1_3)
|
|
|
++#define PBUFFER GLXPbuffer
|
|
|
++#define FBCONFIG GLXFBConfig
|
|
|
++#elif defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
|
|
|
++#define PBUFFER GLXPbufferSGIX
|
|
|
++#define FBCONFIG GLXFBConfigSGIX
|
|
|
++#else
|
|
|
++#define PBUFFER int
|
|
|
++#define FBCONFIG int
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++extern int
|
|
|
++QueryFBConfig(Display *dpy, int screen);
|
|
|
++
|
|
|
++extern int
|
|
|
++QueryPbuffers(Display *dpy, int screen);
|
|
|
++
|
|
|
++
|
|
|
++extern void
|
|
|
++PrintFBConfigInfo(Display *dpy, int screen, FBCONFIG config, Bool horizFormat);
|
|
|
++
|
|
|
++
|
|
|
++extern FBCONFIG *
|
|
|
++ChooseFBConfig(Display *dpy, int screen, const int attribs[], int *nConfigs);
|
|
|
++
|
|
|
++
|
|
|
++extern FBCONFIG *
|
|
|
++GetAllFBConfigs(Display *dpy, int screen, int *nConfigs);
|
|
|
++
|
|
|
++
|
|
|
++extern XVisualInfo *
|
|
|
++GetVisualFromFBConfig(Display *dpy, int screen, FBCONFIG config);
|
|
|
++
|
|
|
++
|
|
|
++extern GLXContext
|
|
|
++CreateContext(Display *dpy, int screen, FBCONFIG config);
|
|
|
++
|
|
|
++
|
|
|
++extern void
|
|
|
++DestroyContext(Display *dpy, GLXContext ctx);
|
|
|
++
|
|
|
++
|
|
|
++extern PBUFFER
|
|
|
++CreatePbuffer(Display *dpy, int screen, FBCONFIG config,
|
|
|
++ int width, int height, Bool preserve, Bool largest);
|
|
|
++
|
|
|
++
|
|
|
++extern void
|
|
|
++DestroyPbuffer(Display *dpy, int screen, PBUFFER pbuffer);
|
|
|
++
|
|
|
++
|
|
|
++#endif /*PBUTIL_H*/
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/shape.c Mesa-7.8.1.patched/progs/xdemos/shape.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/shape.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/shape.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,393 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * Example of using the X "shape" extension with OpenGL: render a spinning
|
|
|
++ * cube inside of a non-rectangular window.
|
|
|
++ *
|
|
|
++ * Press ESC to exit. Press up/down to change window shape.
|
|
|
++ *
|
|
|
++ * To compile add "shape" to the PROGS list in Makefile.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * June 16, 1997
|
|
|
++ *
|
|
|
++ * This program is in the public domain.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <math.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <sys/time.h>
|
|
|
++#include <time.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/Xutil.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <X11/extensions/shape.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++#ifndef PI
|
|
|
++#define PI 3.1415926
|
|
|
++#endif
|
|
|
++
|
|
|
++
|
|
|
++static int Width=500, Height=500;
|
|
|
++
|
|
|
++static float Xangle = 0.0, Yangle = 0.0;
|
|
|
++static int Sides = 5;
|
|
|
++static int MinSides = 3;
|
|
|
++static int MaxSides = 20;
|
|
|
++
|
|
|
++
|
|
|
++/* return current time (in seconds) */
|
|
|
++static double
|
|
|
++current_time(void)
|
|
|
++{
|
|
|
++ struct timeval tv;
|
|
|
++#ifdef __VMS
|
|
|
++ (void) gettimeofday(&tv, NULL );
|
|
|
++#else
|
|
|
++ struct timezone tz;
|
|
|
++ (void) gettimeofday(&tv, &tz);
|
|
|
++#endif
|
|
|
++ return (double) tv.tv_sec + tv.tv_usec / 1000000.0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Draw the OpenGL stuff and do a SwapBuffers.
|
|
|
++ */
|
|
|
++static void display(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ float scale = 1.7;
|
|
|
++
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++
|
|
|
++ glScalef(scale, scale, scale);
|
|
|
++ glRotatef(Xangle, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(Yangle, 0.0, 1.0, 0.0);
|
|
|
++
|
|
|
++ /*
|
|
|
++ * wireframe box
|
|
|
++ */
|
|
|
++ glColor3f(1.0, 1.0, 1.0);
|
|
|
++ glBegin(GL_LINE_LOOP);
|
|
|
++ glVertex3f(-1.0, -1.0, -1.0);
|
|
|
++ glVertex3f( 1.0, -1.0, -1.0);
|
|
|
++ glVertex3f( 1.0, 1.0, -1.0);
|
|
|
++ glVertex3f(-1.0, 1.0, -1.0);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glBegin(GL_LINE_LOOP);
|
|
|
++ glVertex3f(-1.0, -1.0, 1.0);
|
|
|
++ glVertex3f( 1.0, -1.0, 1.0);
|
|
|
++ glVertex3f( 1.0, 1.0, 1.0);
|
|
|
++ glVertex3f(-1.0, 1.0, 1.0);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glBegin(GL_LINES);
|
|
|
++ glVertex3f(-1.0, -1.0, -1.0); glVertex3f(-1.0, -1.0, 1.0);
|
|
|
++ glVertex3f( 1.0, -1.0, -1.0); glVertex3f( 1.0, -1.0, 1.0);
|
|
|
++ glVertex3f( 1.0, 1.0, -1.0); glVertex3f( 1.0, 1.0, 1.0);
|
|
|
++ glVertex3f(-1.0, 1.0, -1.0); glVertex3f(-1.0, 1.0, 1.0);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /*
|
|
|
++ * Solid box
|
|
|
++ */
|
|
|
++ glPushMatrix();
|
|
|
++ glScalef(0.75, 0.75, 0.75);
|
|
|
++
|
|
|
++ glColor3f(1, 0, 0);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex3f(1, -1, -1);
|
|
|
++ glVertex3f(1, 1, -1);
|
|
|
++ glVertex3f(1, 1, 1);
|
|
|
++ glVertex3f(1, -1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glColor3f(0, 1, 1);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex3f(-1, -1, -1);
|
|
|
++ glVertex3f(-1, 1, -1);
|
|
|
++ glVertex3f(-1, 1, 1);
|
|
|
++ glVertex3f(-1, -1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glColor3f(0, 1, 0);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex3f(-1, 1, -1);
|
|
|
++ glVertex3f( 1, 1, -1);
|
|
|
++ glVertex3f( 1, 1, 1);
|
|
|
++ glVertex3f(-1, 1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glColor3f(1, 0, 1);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex3f(-1, -1, -1);
|
|
|
++ glVertex3f( 1, -1, -1);
|
|
|
++ glVertex3f( 1, -1, 1);
|
|
|
++ glVertex3f(-1, -1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glColor3f(0, 0, 1);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex3f(-1, -1, 1);
|
|
|
++ glVertex3f( 1, -1, 1);
|
|
|
++ glVertex3f( 1, 1, 1);
|
|
|
++ glVertex3f(-1, 1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glColor3f(1, 1, 0);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex3f(-1, -1, -1);
|
|
|
++ glVertex3f( 1, -1, -1);
|
|
|
++ glVertex3f( 1, 1, -1);
|
|
|
++ glVertex3f(-1, 1, -1);
|
|
|
++ glEnd();
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * This is called when we have to recompute the window shape bitmask.
|
|
|
++ * We just generate an n-sided regular polygon here but any other shape
|
|
|
++ * would be possible.
|
|
|
++ */
|
|
|
++static void make_shape_mask(Display *dpy, Window win, int width, int height,
|
|
|
++ int sides)
|
|
|
++{
|
|
|
++ Pixmap shapeMask;
|
|
|
++ XGCValues xgcv;
|
|
|
++ GC gc;
|
|
|
++
|
|
|
++ /* allocate 1-bit deep pixmap and a GC */
|
|
|
++ shapeMask = XCreatePixmap(dpy, win, width, height, 1);
|
|
|
++ gc = XCreateGC(dpy, shapeMask, 0, &xgcv);
|
|
|
++
|
|
|
++ /* clear shapeMask to zeros */
|
|
|
++ XSetForeground(dpy, gc, 0);
|
|
|
++ XFillRectangle(dpy, shapeMask, gc, 0, 0, width, height);
|
|
|
++
|
|
|
++ /* draw mask */
|
|
|
++ XSetForeground(dpy, gc, 1);
|
|
|
++ {
|
|
|
++ int cx = width / 2;
|
|
|
++ int cy = height / 2;
|
|
|
++ float angle = 0.0;
|
|
|
++ float step = 2.0 * PI / sides;
|
|
|
++ float radius = width / 2;
|
|
|
++ int i;
|
|
|
++ XPoint points[100];
|
|
|
++ for (i=0;i<sides;i++) {
|
|
|
++ int x = cx + radius * sin(angle);
|
|
|
++ int y = cy - radius * cos(angle);
|
|
|
++ points[i].x = x;
|
|
|
++ points[i].y = y;
|
|
|
++ angle += step;
|
|
|
++ }
|
|
|
++ XFillPolygon(dpy, shapeMask, gc, points, sides, Convex, CoordModeOrigin);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* This is the only SHAPE extension call- simple! */
|
|
|
++ XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, shapeMask, ShapeSet);
|
|
|
++
|
|
|
++ XFreeGC(dpy, gc);
|
|
|
++ XFreePixmap(dpy, shapeMask);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Called when window is resized. Do OpenGL viewport and projection stuff.
|
|
|
++ */
|
|
|
++static void reshape(int width, int height)
|
|
|
++{
|
|
|
++ glViewport(0, 0, width, height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-1.0, 1.0, -1.0, 1.0, 3.0, 20.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0.0, 0.0, -10.0);
|
|
|
++
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Process X events.
|
|
|
++ */
|
|
|
++static void event_loop(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ XEvent event;
|
|
|
++ if (XPending(dpy)) {
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ display(dpy, event.xexpose.window);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ Width = event.xconfigure.width;
|
|
|
++ Height = event.xconfigure.height,
|
|
|
++ make_shape_mask(dpy, win, Width, Height, Sides);
|
|
|
++ reshape(Width, Height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buf[100];
|
|
|
++ KeySym keySym;
|
|
|
++ XComposeStatus stat;
|
|
|
++ XLookupString(&event.xkey, buf, sizeof(buf), &keySym, &stat);
|
|
|
++ switch (keySym) {
|
|
|
++ case XK_Escape:
|
|
|
++ exit(0);
|
|
|
++ break;
|
|
|
++ case XK_Up:
|
|
|
++ Sides++;
|
|
|
++ if (Sides>MaxSides) Sides = MaxSides;
|
|
|
++ make_shape_mask(dpy, win, Width, Height, Sides);
|
|
|
++ break;
|
|
|
++ case XK_Down:
|
|
|
++ Sides--;
|
|
|
++ if (Sides<MinSides) Sides = MinSides;
|
|
|
++ make_shape_mask(dpy, win, Width, Height, Sides);
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ ;;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ static double t0 = -1.0;
|
|
|
++ double dt, t = current_time();
|
|
|
++ if (t0 < 0.0)
|
|
|
++ t0 = t;
|
|
|
++ dt = t - t0;
|
|
|
++ Xangle += 90.0 * dt; /* 90 degrees per second */
|
|
|
++ Yangle += 70.0 * dt;
|
|
|
++ t0 = t;
|
|
|
++ display(dpy, win);
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Allocate a "nice" colormap. This could be better (HP-CR support, etc).
|
|
|
++ */
|
|
|
++static Colormap alloc_colormap(Display *dpy, Window parent, Visual *vis)
|
|
|
++{
|
|
|
++ Screen *scr = DefaultScreenOfDisplay(dpy);
|
|
|
++ int scrnum = DefaultScreen(dpy);
|
|
|
++
|
|
|
++ if (MaxCmapsOfScreen(scr)==1 && vis==DefaultVisual(dpy, scrnum)) {
|
|
|
++ /* The window and root are of the same visual type so */
|
|
|
++ /* share the root colormap. */
|
|
|
++ return DefaultColormap(dpy, scrnum);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ return XCreateColormap(dpy, parent, vis, AllocNone);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ static int glAttribs[] = {
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_RGBA,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None
|
|
|
++ };
|
|
|
++ Display *dpy;
|
|
|
++ XVisualInfo *visInfo;
|
|
|
++ int scrn;
|
|
|
++ Window root;
|
|
|
++ Colormap cmap;
|
|
|
++ Window win;
|
|
|
++ XSetWindowAttributes winAttribs;
|
|
|
++ unsigned long winAttribsMask;
|
|
|
++ GLXContext glCtx;
|
|
|
++ int ignore;
|
|
|
++ const char *name = "OpenGL in a Shaped Window";
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++ if (!dpy) {
|
|
|
++ fprintf(stderr, "Couldn't open default display\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* check that we can use the shape extension */
|
|
|
++ if (!XQueryExtension(dpy, "SHAPE", &ignore, &ignore, &ignore )) {
|
|
|
++ fprintf(stderr, "Display doesn't support shape extension\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++
|
|
|
++ scrn = DefaultScreen(dpy);
|
|
|
++
|
|
|
++ root = RootWindow(dpy, scrn);
|
|
|
++
|
|
|
++ visInfo = glXChooseVisual(dpy, scrn, glAttribs);
|
|
|
++ if (!visInfo) {
|
|
|
++ fprintf(stderr, "Couldn't get RGB, DB, Z visual\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++
|
|
|
++ glCtx = glXCreateContext(dpy, visInfo, 0, True);
|
|
|
++ if (!glCtx) {
|
|
|
++ fprintf(stderr, "Couldn't create GL context\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++
|
|
|
++ cmap = alloc_colormap(dpy, root, visInfo->visual);
|
|
|
++ if (!cmap) {
|
|
|
++ fprintf(stderr, "Couln't create colormap\n");
|
|
|
++ return 1;
|
|
|
++ }
|
|
|
++
|
|
|
++ winAttribs.border_pixel = 0;
|
|
|
++ winAttribs.colormap = cmap;
|
|
|
++ winAttribs.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ winAttribsMask = CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++ win = XCreateWindow(dpy, root, 0, 0, Width, Height, 0,
|
|
|
++ visInfo->depth, InputOutput,
|
|
|
++ visInfo->visual,
|
|
|
++ winAttribsMask, &winAttribs);
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ /*
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ */
|
|
|
++ sizehints.flags = 0;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, win, glCtx);
|
|
|
++
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("Press ESC to exit.\n");
|
|
|
++ printf("Press up/down to change window shape.\n");
|
|
|
++
|
|
|
++ event_loop(dpy, win);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/sharedtex.c Mesa-7.8.1.patched/progs/xdemos/sharedtex.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/sharedtex.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/sharedtex.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,324 @@
|
|
|
++/*
|
|
|
++ * Test sharing of texture objects by two rendering contexts.
|
|
|
++ * In particular, test that changing a texture object in one context
|
|
|
++ * effects the texture in the second context.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ * 30 Apr 2008
|
|
|
++ *
|
|
|
++ * Copyright (C) 2008 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <assert.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++
|
|
|
++
|
|
|
++#define MAX_CONTEXTS 2
|
|
|
++
|
|
|
++#define TEX_SIZE 32
|
|
|
++
|
|
|
++static const char *DisplayName = NULL;
|
|
|
++static Display *Dpy;
|
|
|
++static XVisualInfo *VisInfo;
|
|
|
++static Window Win;
|
|
|
++static GLXContext Contexts[MAX_CONTEXTS];
|
|
|
++static int WinWidth = 300, WinHeight = 300;
|
|
|
++
|
|
|
++static int DrawContext = 0, TexContext = 1;
|
|
|
++
|
|
|
++static GLuint TexObj = 0;
|
|
|
++static GLboolean NewTexture = GL_FALSE;
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Error(const char *msg)
|
|
|
++{
|
|
|
++ fprintf(stderr, "sharedtex error: %s\n", msg);
|
|
|
++ exit(1);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++CreateWindow(const char *name)
|
|
|
++{
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ int xpos = 0, ypos = 0;
|
|
|
++ static int n = 0;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(Dpy);
|
|
|
++ root = RootWindow(Dpy, scrnum);
|
|
|
++
|
|
|
++ VisInfo = glXChooseVisual(Dpy, scrnum, attrib);
|
|
|
++ if (!VisInfo) {
|
|
|
++ Error("Unable to find RGB, double-buffered visual");
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ xpos = (n % 10) * 100;
|
|
|
++ ypos = (n / 10) * 100;
|
|
|
++ n++;
|
|
|
++
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(Dpy, root, VisInfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ Win = XCreateWindow(Dpy, root, xpos, ypos, WinWidth, WinHeight,
|
|
|
++ 0, VisInfo->depth, InputOutput,
|
|
|
++ VisInfo->visual, mask, &attr);
|
|
|
++ if (!Win) {
|
|
|
++ Error("Couldn't create window");
|
|
|
++ }
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = WinWidth;
|
|
|
++ sizehints.height = WinHeight;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(Dpy, Win, &sizehints);
|
|
|
++ XSetStandardProperties(Dpy, Win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ XMapWindow(Dpy, Win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Change texture image, using TexContext
|
|
|
++ */
|
|
|
++static void
|
|
|
++ModifyTexture(void)
|
|
|
++{
|
|
|
++ GLuint tex[TEX_SIZE][TEX_SIZE];
|
|
|
++ GLuint c0, c1;
|
|
|
++ int i, j;
|
|
|
++
|
|
|
++ if (Win && !glXMakeCurrent(Dpy, Win, Contexts[TexContext])) {
|
|
|
++ Error("glXMakeCurrent failed");
|
|
|
++ }
|
|
|
++
|
|
|
++ /* choose two random colors */
|
|
|
++ c0 = rand() & 0xffffffff;
|
|
|
++ c1 = rand() & 0xffffffff;
|
|
|
++
|
|
|
++ for (i = 0; i < TEX_SIZE; i++) {
|
|
|
++ for (j = 0; j < TEX_SIZE; j++) {
|
|
|
++ if (((i / 4) ^ (j / 4)) & 1) {
|
|
|
++ tex[i][j] = c0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ tex[i][j] = c1;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ glBindTexture(GL_TEXTURE_2D, TexObj);
|
|
|
++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0,
|
|
|
++ GL_RGBA, GL_UNSIGNED_BYTE, tex);
|
|
|
++
|
|
|
++ NewTexture = GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++InitContext(void)
|
|
|
++{
|
|
|
++ glGenTextures(1, &TexObj);
|
|
|
++ assert(TexObj);
|
|
|
++ glBindTexture(GL_TEXTURE_2D, TexObj);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
++ glEnable(GL_TEXTURE_2D);
|
|
|
++
|
|
|
++ printf("GL_RENDERER = %s\n", (char*) glGetString(GL_RENDERER));
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Setup(void)
|
|
|
++{
|
|
|
++ int i;
|
|
|
++
|
|
|
++ Dpy = XOpenDisplay(DisplayName);
|
|
|
++ if (!Dpy) {
|
|
|
++ Error("Unable to open display");
|
|
|
++ }
|
|
|
++
|
|
|
++ CreateWindow("sharedtex");
|
|
|
++
|
|
|
++ for (i = 0; i < MAX_CONTEXTS; i++) {
|
|
|
++ GLXContext share = i > 0 ? Contexts[0] : 0;
|
|
|
++
|
|
|
++ Contexts[i] = glXCreateContext(Dpy, VisInfo, share, True);
|
|
|
++ if (!Contexts[i]) {
|
|
|
++ Error("Unable to create GLX context");
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!glXMakeCurrent(Dpy, Win, Contexts[i])) {
|
|
|
++ Error("glXMakeCurrent failed");
|
|
|
++ }
|
|
|
++
|
|
|
++ InitContext();
|
|
|
++ }
|
|
|
++
|
|
|
++ ModifyTexture();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Redraw window, using DrawContext
|
|
|
++ */
|
|
|
++static void
|
|
|
++Redraw(void)
|
|
|
++{
|
|
|
++ static float rot = 0.0;
|
|
|
++ float ar;
|
|
|
++
|
|
|
++ rot += 1.0;
|
|
|
++
|
|
|
++ if (Win && !glXMakeCurrent(Dpy, Win, Contexts[DrawContext])) {
|
|
|
++ Error("glXMakeCurrent failed");
|
|
|
++ }
|
|
|
++
|
|
|
++ glViewport(0, 0, WinWidth, WinHeight);
|
|
|
++ ar = (float) WinWidth / (float) WinHeight;
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-ar, ar, -1.0, 1.0, -1.0, 1.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++ glClearColor(0.5, 0.5, 0.5, 1.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(rot, 0, 0, 1);
|
|
|
++ glScalef(0.7, 0.7, 0.7);
|
|
|
++
|
|
|
++ if (NewTexture) {
|
|
|
++ /* rebind to get new contents */
|
|
|
++ glBindTexture(GL_TEXTURE_2D, TexObj);
|
|
|
++ NewTexture = GL_FALSE;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* draw textured quad */
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glTexCoord2f( 0.0, 0.0 ); glVertex2f( -1.0, -1.0 );
|
|
|
++ glTexCoord2f( 1.0, 0.0 ); glVertex2f( 1.0, -1.0 );
|
|
|
++ glTexCoord2f( 1.0, 1.0 ); glVertex2f( 1.0, 1.0 );
|
|
|
++ glTexCoord2f( 0.0, 1.0 ); glVertex2f( -1.0, 1.0 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ if (Win)
|
|
|
++ glXSwapBuffers(Dpy, Win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++EventLoop(void)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ while (XPending(Dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(Dpy, &event);
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ Redraw();
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ WinWidth = event.xconfigure.width;
|
|
|
++ WinHeight = event.xconfigure.height;
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buf[100];
|
|
|
++ KeySym keySym;
|
|
|
++ XComposeStatus stat;
|
|
|
++ XLookupString(&event.xkey, buf, sizeof(buf), &keySym, &stat);
|
|
|
++ switch (keySym) {
|
|
|
++ case XK_Escape:
|
|
|
++ exit(0);
|
|
|
++ break;
|
|
|
++ case XK_t:
|
|
|
++ case XK_T:
|
|
|
++ ModifyTexture();
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ Redraw();
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ /*no-op*/ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ Redraw();
|
|
|
++ usleep(10000);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0 && i < argc) {
|
|
|
++ DisplayName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ Setup();
|
|
|
++
|
|
|
++ printf("Press 't' to change texture image/colors\n");
|
|
|
++
|
|
|
++ EventLoop();
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/sharedtex_mt.c Mesa-7.8.1.patched/progs/xdemos/sharedtex_mt.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/sharedtex_mt.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/sharedtex_mt.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,490 @@
|
|
|
++/* $Id: sharedtex.c,v 1.2 2002/01/16 14:32:46 joukj Exp $ */
|
|
|
++
|
|
|
++/*
|
|
|
++ * Test sharing of display lists and texture objects between GLX contests.
|
|
|
++ * Brian Paul
|
|
|
++ * Summer 2000
|
|
|
++ *
|
|
|
++ *
|
|
|
++ * Copyright (C) 2000 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ *
|
|
|
++ * Modified 2009 for multithreading by Thomas Hellstrom.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <unistd.h>
|
|
|
++#include <string.h>
|
|
|
++#include <pthread.h>
|
|
|
++#include <X11/X.h>
|
|
|
++
|
|
|
++struct thread_init_arg {
|
|
|
++ int id;
|
|
|
++};
|
|
|
++
|
|
|
++struct window {
|
|
|
++ pthread_mutex_t drawMutex;
|
|
|
++ char DisplayName[1000];
|
|
|
++ Display *Dpy;
|
|
|
++ Window Win;
|
|
|
++ GLXContext Context;
|
|
|
++ float Angle;
|
|
|
++ int Id;
|
|
|
++ XVisualInfo *visInfo;
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++#define MAX_WINDOWS 20
|
|
|
++static struct window Windows[MAX_WINDOWS];
|
|
|
++static int NumWindows = 0;
|
|
|
++static int terminate = 0;
|
|
|
++static GLXContext gCtx;
|
|
|
++static Display *gDpy;
|
|
|
++static GLuint Textures[3];
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Error(const char *display, const char *msg)
|
|
|
++{
|
|
|
++ fprintf(stderr, "Error on display %s - %s\n", display, msg);
|
|
|
++ exit(1);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static int
|
|
|
++initMainthread(Display *dpy, const char *displayName)
|
|
|
++{
|
|
|
++ int scrnum;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(dpy);
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attrib);
|
|
|
++ if (!visinfo) {
|
|
|
++ Error(displayName, "Unable to find RGB, double-buffered visual");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++ gCtx = glXCreateContext(dpy, visinfo, NULL, True);
|
|
|
++ if (!gCtx) {
|
|
|
++ Error(displayName, "Couldn't create GLX context");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++static struct window *
|
|
|
++AddWindow(Display *dpy, const char *displayName, int xpos, int ypos,
|
|
|
++ GLXContext sCtx)
|
|
|
++{
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int width = 300, height = 300;
|
|
|
++
|
|
|
++ if (NumWindows >= MAX_WINDOWS)
|
|
|
++ return NULL;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen(dpy);
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(dpy, scrnum, attrib);
|
|
|
++ if (!visinfo) {
|
|
|
++ Error(displayName, "Unable to find RGB, double-buffered visual");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow(dpy, root, xpos, ypos, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++ if (!win) {
|
|
|
++ Error(displayName, "Couldn't create window");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, displayName, displayName,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ ctx = glXCreateContext(dpy, visinfo,
|
|
|
++ sCtx ? sCtx : NULL, True);
|
|
|
++
|
|
|
++ if (!ctx) {
|
|
|
++ Error(displayName, "Couldn't create GLX context");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++
|
|
|
++ /* save the info for this window */
|
|
|
++ {
|
|
|
++ static int id = 0;
|
|
|
++ struct window *h = &Windows[NumWindows];
|
|
|
++ if (strlen(displayName) + 1 > sizeof(h->DisplayName)) {
|
|
|
++ Error(displayName, "string overflow");
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++ strcpy(h->DisplayName, displayName);
|
|
|
++ h->Dpy = dpy;
|
|
|
++ h->Win = win;
|
|
|
++ h->Context = ctx;
|
|
|
++ h->Angle = 0.0;
|
|
|
++ h->Id = id++;
|
|
|
++ h->visInfo = visinfo;
|
|
|
++ pthread_mutex_init(&h->drawMutex, NULL);
|
|
|
++ NumWindows++;
|
|
|
++ return &Windows[NumWindows-1];
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++InitGLstuff(void)
|
|
|
++
|
|
|
++{
|
|
|
++ glGenTextures(3, Textures);
|
|
|
++
|
|
|
++ /* setup first texture object */
|
|
|
++ {
|
|
|
++ GLubyte image[16][16][4];
|
|
|
++ GLint i, j;
|
|
|
++ glBindTexture(GL_TEXTURE_2D, Textures[0]);
|
|
|
++
|
|
|
++ /* red/white checkerboard */
|
|
|
++ for (i = 0; i < 16; i++) {
|
|
|
++ for (j = 0; j < 16; j++) {
|
|
|
++ if ((i ^ j) & 1) {
|
|
|
++ image[i][j][0] = 255;
|
|
|
++ image[i][j][1] = 255;
|
|
|
++ image[i][j][2] = 255;
|
|
|
++ image[i][j][3] = 255;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ image[i][j][0] = 255;
|
|
|
++ image[i][j][1] = 0;
|
|
|
++ image[i][j][2] = 0;
|
|
|
++ image[i][j][3] = 255;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA,
|
|
|
++ GL_UNSIGNED_BYTE, image);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* setup second texture object */
|
|
|
++ {
|
|
|
++ GLubyte image[8][8][3];
|
|
|
++ GLint i, j;
|
|
|
++ glBindTexture(GL_TEXTURE_2D, Textures[1]);
|
|
|
++
|
|
|
++ /* green/yellow checkerboard */
|
|
|
++ for (i = 0; i < 8; i++) {
|
|
|
++ for (j = 0; j < 8; j++) {
|
|
|
++ if ((i ^ j) & 1) {
|
|
|
++ image[i][j][0] = 0;
|
|
|
++ image[i][j][1] = 255;
|
|
|
++ image[i][j][2] = 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ image[i][j][0] = 255;
|
|
|
++ image[i][j][1] = 255;
|
|
|
++ image[i][j][2] = 0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
|
|
|
++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB,
|
|
|
++ GL_UNSIGNED_BYTE, image);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* setup second texture object */
|
|
|
++ {
|
|
|
++ GLubyte image[4][4][3];
|
|
|
++ GLint i, j;
|
|
|
++ glBindTexture(GL_TEXTURE_2D, Textures[2]);
|
|
|
++
|
|
|
++ /* blue/gray checkerboard */
|
|
|
++ for (i = 0; i < 4; i++) {
|
|
|
++ for (j = 0; j < 4; j++) {
|
|
|
++ if ((i ^ j) & 1) {
|
|
|
++ image[i][j][0] = 0;
|
|
|
++ image[i][j][1] = 0;
|
|
|
++ image[i][j][2] = 255;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ image[i][j][0] = 200;
|
|
|
++ image[i][j][1] = 200;
|
|
|
++ image[i][j][2] = 200;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
|
|
|
++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 4, 4, 0, GL_RGB,
|
|
|
++ GL_UNSIGNED_BYTE, image);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Now make the cube object display list */
|
|
|
++
|
|
|
++ printf("GL_RENDERER: %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION: %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR: %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++Redraw(struct window *h)
|
|
|
++{
|
|
|
++ pthread_mutex_lock(&h->drawMutex);
|
|
|
++ if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed in Redraw");
|
|
|
++ pthread_mutex_unlock(&h->drawMutex);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ h->Angle += 1.0;
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++ glClearColor(0.25, 0.25, 0.25, 1.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
++
|
|
|
++ glEnable(GL_TEXTURE_2D);
|
|
|
++ glEnable(GL_DEPTH_TEST);
|
|
|
++ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
++
|
|
|
++ glColor3f(1, 1, 1);
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ if (h->Id == 0)
|
|
|
++ glRotatef(h->Angle, 0, 1, -1);
|
|
|
++ else if (h->Id == 1)
|
|
|
++ glRotatef(-(h->Angle), 0, 1, -1);
|
|
|
++ else if (h->Id == 2)
|
|
|
++ glRotatef(h->Angle, 0, 1, 1);
|
|
|
++ else if (h->Id == 3)
|
|
|
++ glRotatef(-(h->Angle), 0, 1, 1);
|
|
|
++ glBindTexture(GL_TEXTURE_2D, Textures[0]);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f(-1, 1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f(-1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, -1, 1);
|
|
|
++ glEnd();
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f(1, 1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f(1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(1, -1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glBindTexture(GL_TEXTURE_2D, Textures[1]);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, -1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, -1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, -1, 1);
|
|
|
++ glEnd();
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, 1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, 1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, 1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glBindTexture(GL_TEXTURE_2D, Textures[2]);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, -1, -1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, 1, -1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, 1, -1);
|
|
|
++ glEnd();
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glTexCoord2f(0, 0); glVertex3f(-1, -1, 1);
|
|
|
++ glTexCoord2f(1, 0); glVertex3f( 1, -1, 1);
|
|
|
++ glTexCoord2f(1, 1); glVertex3f( 1, 1, 1);
|
|
|
++ glTexCoord2f(0, 1); glVertex3f(-1, 1, 1);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glXSwapBuffers(h->Dpy, h->Win);
|
|
|
++
|
|
|
++ if (!glXMakeCurrent(h->Dpy, None, NULL)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed in Redraw");
|
|
|
++ }
|
|
|
++ pthread_mutex_unlock(&h->drawMutex);
|
|
|
++}
|
|
|
++
|
|
|
++static void *threadRunner (void *arg)
|
|
|
++{
|
|
|
++ struct thread_init_arg *tia = (struct thread_init_arg *) arg;
|
|
|
++ struct window *win;
|
|
|
++
|
|
|
++ win = &Windows[tia->id];
|
|
|
++
|
|
|
++ while(!terminate) {
|
|
|
++ usleep(1000);
|
|
|
++ Redraw(win);
|
|
|
++ }
|
|
|
++
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++static void
|
|
|
++Resize(struct window *h, unsigned int width, unsigned int height)
|
|
|
++{
|
|
|
++ pthread_mutex_lock(&h->drawMutex);
|
|
|
++
|
|
|
++ if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed in Resize()");
|
|
|
++ pthread_mutex_unlock(&h->drawMutex);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ glViewport(0, 0, width, height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum(-1, 1, -1, 1, 2, 10);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef(0, 0, -4.5);
|
|
|
++ if (!glXMakeCurrent(h->Dpy, None, NULL)) {
|
|
|
++ Error(h->DisplayName, "glXMakeCurrent failed in Resize()");
|
|
|
++ }
|
|
|
++ pthread_mutex_unlock(&h->drawMutex);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++EventLoop(void)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ int i;
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(gDpy, &event);
|
|
|
++ for (i = 0; i < NumWindows; i++) {
|
|
|
++ struct window *h = &Windows[i];
|
|
|
++ if (event.xany.window == h->Win) {
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ Redraw(h);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ Resize(h, event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ terminate = 1;
|
|
|
++ return;
|
|
|
++ default:
|
|
|
++ /*no-op*/ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ const char *dpyName = XDisplayName(NULL);
|
|
|
++ pthread_t t0, t1, t2, t3;
|
|
|
++ struct thread_init_arg tia0, tia1, tia2, tia3;
|
|
|
++ struct window *h0;
|
|
|
++
|
|
|
++ XInitThreads();
|
|
|
++
|
|
|
++ gDpy = XOpenDisplay(dpyName);
|
|
|
++ if (!gDpy) {
|
|
|
++ Error(dpyName, "Unable to open display");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (initMainthread(gDpy, dpyName))
|
|
|
++ return -1;
|
|
|
++
|
|
|
++ /* four windows and contexts sharing display lists and texture objects */
|
|
|
++ h0 = AddWindow(gDpy, dpyName, 10, 10, gCtx);
|
|
|
++ (void) AddWindow(gDpy, dpyName, 330, 10, gCtx);
|
|
|
++ (void) AddWindow(gDpy, dpyName, 10, 350, gCtx);
|
|
|
++ (void) AddWindow(gDpy, dpyName, 330, 350, gCtx);
|
|
|
++
|
|
|
++ if (!glXMakeCurrent(gDpy, h0->Win, gCtx)) {
|
|
|
++ Error(dpyName, "glXMakeCurrent failed for init thread.");
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ InitGLstuff();
|
|
|
++
|
|
|
++ tia0.id = 0;
|
|
|
++ pthread_create(&t0, NULL, threadRunner, &tia0);
|
|
|
++ tia1.id = 1;
|
|
|
++ pthread_create(&t1, NULL, threadRunner, &tia1);
|
|
|
++ tia2.id = 2;
|
|
|
++ pthread_create(&t2, NULL, threadRunner, &tia2);
|
|
|
++ tia3.id = 3;
|
|
|
++ pthread_create(&t3, NULL, threadRunner, &tia3);
|
|
|
++ EventLoop();
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/texture_from_pixmap.c Mesa-7.8.1.patched/progs/xdemos/texture_from_pixmap.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/texture_from_pixmap.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/texture_from_pixmap.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,396 @@
|
|
|
++/*
|
|
|
++ * Mesa 3-D graphics library
|
|
|
++ * Version: 7.1
|
|
|
++ *
|
|
|
++ * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Test the GLX_EXT_texture_from_pixmap extension
|
|
|
++ * Brian Paul
|
|
|
++ * 19 May 2007
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#define GL_GLEXT_PROTOTYPES
|
|
|
++#define GLX_GLXEXT_PROTOTYPES
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++
|
|
|
++static float top, bottom;
|
|
|
++
|
|
|
++static PFNGLXBINDTEXIMAGEEXTPROC glXBindTexImageEXT_func = NULL;
|
|
|
++static PFNGLXRELEASETEXIMAGEEXTPROC glXReleaseTexImageEXT_func = NULL;
|
|
|
++
|
|
|
++
|
|
|
++static Display *
|
|
|
++OpenDisplay(void)
|
|
|
++{
|
|
|
++ int screen;
|
|
|
++ Display *dpy;
|
|
|
++ const char *ext;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Couldn't open default display!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ screen = DefaultScreen(dpy);
|
|
|
++ ext = glXQueryExtensionsString(dpy, screen);
|
|
|
++ if (!strstr(ext, "GLX_EXT_texture_from_pixmap")) {
|
|
|
++ fprintf(stderr, "GLX_EXT_texture_from_pixmap not supported.\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXBindTexImageEXT_func = (PFNGLXBINDTEXIMAGEEXTPROC)
|
|
|
++ glXGetProcAddress((GLubyte *) "glXBindTexImageEXT");
|
|
|
++ glXReleaseTexImageEXT_func = (PFNGLXRELEASETEXIMAGEEXTPROC)
|
|
|
++ glXGetProcAddress((GLubyte*) "glXReleaseTexImageEXT");
|
|
|
++
|
|
|
++ if (!glXBindTexImageEXT_func || !glXReleaseTexImageEXT_func) {
|
|
|
++ fprintf(stderr, "glXGetProcAddress failed!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ return dpy;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static GLXFBConfig
|
|
|
++ChoosePixmapFBConfig(Display *display)
|
|
|
++{
|
|
|
++ int screen = DefaultScreen(display);
|
|
|
++ GLXFBConfig *fbconfigs;
|
|
|
++ int i, nfbconfigs = 0, value;
|
|
|
++
|
|
|
++ fbconfigs = glXGetFBConfigs(display, screen, &nfbconfigs);
|
|
|
++ for (i = 0; i < nfbconfigs; i++) {
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(display, fbconfigs[i], GLX_DRAWABLE_TYPE, &value);
|
|
|
++ if (!(value & GLX_PIXMAP_BIT))
|
|
|
++ continue;
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(display, fbconfigs[i],
|
|
|
++ GLX_BIND_TO_TEXTURE_TARGETS_EXT, &value);
|
|
|
++ if (!(value & GLX_TEXTURE_2D_BIT_EXT))
|
|
|
++ continue;
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(display, fbconfigs[i],
|
|
|
++ GLX_BIND_TO_TEXTURE_RGBA_EXT, &value);
|
|
|
++ if (value == False) {
|
|
|
++ glXGetFBConfigAttrib(display, fbconfigs[i],
|
|
|
++ GLX_BIND_TO_TEXTURE_RGB_EXT, &value);
|
|
|
++ if (value == False)
|
|
|
++ continue;
|
|
|
++ }
|
|
|
++
|
|
|
++ glXGetFBConfigAttrib(display, fbconfigs[i],
|
|
|
++ GLX_Y_INVERTED_EXT, &value);
|
|
|
++ if (value == True) {
|
|
|
++ top = 0.0f;
|
|
|
++ bottom = 1.0f;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ top = 1.0f;
|
|
|
++ bottom = 0.0f;
|
|
|
++ }
|
|
|
++
|
|
|
++ break;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (i == nfbconfigs) {
|
|
|
++ printf("Unable to find FBconfig for texturing\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ return fbconfigs[i];
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static GLXPixmap
|
|
|
++CreatePixmap(Display *dpy, GLXFBConfig config, int w, int h, Pixmap *p)
|
|
|
++{
|
|
|
++ GLXPixmap gp;
|
|
|
++ const int pixmapAttribs[] = {
|
|
|
++ GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
|
|
|
++ GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
|
|
|
++ None
|
|
|
++ };
|
|
|
++ Window root = RootWindow(dpy, 0);
|
|
|
++
|
|
|
++ *p = XCreatePixmap(dpy, root, w, h, 24);
|
|
|
++ XSync(dpy, 0);
|
|
|
++ gp = glXCreatePixmap(dpy, config, *p, pixmapAttribs);
|
|
|
++ XSync(dpy, 0);
|
|
|
++
|
|
|
++ return gp;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++DrawPixmapImage(Display *dpy, Pixmap pm, int w, int h)
|
|
|
++{
|
|
|
++ XGCValues gcvals;
|
|
|
++ GC gc;
|
|
|
++
|
|
|
++ gcvals.background = 0;
|
|
|
++ gc = XCreateGC(dpy, pm, GCBackground, &gcvals);
|
|
|
++
|
|
|
++ XSetForeground(dpy, gc, 0x0);
|
|
|
++ XFillRectangle(dpy, pm, gc, 0, 0, w, h);
|
|
|
++
|
|
|
++ XSetForeground(dpy, gc, 0xff0000);
|
|
|
++ XFillRectangle(dpy, pm, gc, 0, 0, 50, 50);
|
|
|
++
|
|
|
++ XSetForeground(dpy, gc, 0x00ff00);
|
|
|
++ XFillRectangle(dpy, pm, gc, w - 50, 0, 50, 50);
|
|
|
++
|
|
|
++ XSetForeground(dpy, gc, 0x0000ff);
|
|
|
++ XFillRectangle(dpy, pm, gc, 0, h - 50, 50, 50);
|
|
|
++
|
|
|
++ XSetForeground(dpy, gc, 0xffffff);
|
|
|
++ XFillRectangle(dpy, pm, gc, h - 50, h - 50, 50, 50);
|
|
|
++
|
|
|
++ XSetForeground(dpy, gc, 0xffff00);
|
|
|
++ XSetLineAttributes(dpy, gc, 3, LineSolid, CapButt, JoinBevel);
|
|
|
++ XDrawLine(dpy, pm, gc, 0, 0, w, h);
|
|
|
++ XDrawLine(dpy, pm, gc, 0, h, w, 0);
|
|
|
++
|
|
|
++ XFreeGC(dpy, gc);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static XVisualInfo *
|
|
|
++ChooseWindowVisual(Display *dpy)
|
|
|
++{
|
|
|
++ int screen = DefaultScreen(dpy);
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int attribs[] = {
|
|
|
++ GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None
|
|
|
++ };
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(dpy, screen, attribs);
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Unable to find RGB, double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ return visinfo;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static Window
|
|
|
++CreateWindow(Display *dpy, XVisualInfo *visinfo,
|
|
|
++ int width, int height, const char *name)
|
|
|
++{
|
|
|
++ int screen = DefaultScreen(dpy);
|
|
|
++ Window win;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++
|
|
|
++ root = RootWindow(dpy, screen);
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow(dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++ if (win) {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ }
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++BindPixmapTexture(Display *dpy, GLXPixmap gp)
|
|
|
++{
|
|
|
++ GLuint texture;
|
|
|
++
|
|
|
++ glGenTextures(1, &texture);
|
|
|
++ glBindTexture(GL_TEXTURE_2D, texture);
|
|
|
++
|
|
|
++ glXBindTexImageEXT_func(dpy, gp, GLX_FRONT_LEFT_EXT, NULL);
|
|
|
++
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
++
|
|
|
++ glEnable(GL_TEXTURE_2D);
|
|
|
++ /*
|
|
|
++ glXReleaseTexImageEXT_func(display, glxpixmap, GLX_FRONT_LEFT_EXT);
|
|
|
++ */
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Resize(Window win, unsigned int width, unsigned int height)
|
|
|
++{
|
|
|
++ float sz = 1.5;
|
|
|
++ glViewport(0, 0, width, height);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-sz, sz, -sz, sz, -1.0, 1.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Redraw(Display *dpy, Window win, float rot)
|
|
|
++{
|
|
|
++ glClearColor(0.25, 0.25, 0.25, 0.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(rot, 0, 0, 1);
|
|
|
++ glRotatef(2.0 * rot, 1, 0, 0);
|
|
|
++
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++ glTexCoord2d(0.0, bottom);
|
|
|
++ glVertex2f(-1, -1);
|
|
|
++ glTexCoord2d(1.0, bottom);
|
|
|
++ glVertex2f( 1, -1);
|
|
|
++ glTexCoord2d(1.0, top);
|
|
|
++ glVertex2d(1.0, 1.0);
|
|
|
++ glTexCoord2d(0.0, top);
|
|
|
++ glVertex2f(-1.0, 1.0);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++EventLoop(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ GLfloat rot = 0.0;
|
|
|
++ int anim = 0;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ if (!anim || XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ Redraw(dpy, win, rot);
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ Resize(event.xany.window,
|
|
|
++ event.xconfigure.width,
|
|
|
++ event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buf[100];
|
|
|
++ KeySym keySym;
|
|
|
++ XComposeStatus stat;
|
|
|
++ XLookupString(&event.xkey, buf, sizeof(buf), &keySym, &stat);
|
|
|
++ if (keySym == XK_Escape) {
|
|
|
++ return; /* exit */
|
|
|
++ }
|
|
|
++ else if (keySym == XK_r) {
|
|
|
++ rot += 1.0;
|
|
|
++ Redraw(dpy, win, rot);
|
|
|
++ }
|
|
|
++ else if (keySym == XK_a) {
|
|
|
++ anim = !anim;
|
|
|
++ }
|
|
|
++ else if (keySym == XK_R) {
|
|
|
++ rot -= 1.0;
|
|
|
++ Redraw(dpy, win, rot);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ ; /*no-op*/
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* animate */
|
|
|
++ rot += 1.0;
|
|
|
++ Redraw(dpy, win, rot);
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ GLXFBConfig pixmapConfig;
|
|
|
++ XVisualInfo *windowVis;
|
|
|
++ GLXPixmap gp;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ Pixmap p;
|
|
|
++
|
|
|
++ dpy = OpenDisplay();
|
|
|
++
|
|
|
++ pixmapConfig = ChoosePixmapFBConfig(dpy);
|
|
|
++ windowVis = ChooseWindowVisual(dpy);
|
|
|
++ win = CreateWindow(dpy, windowVis, 500, 500, "Texture From Pixmap");
|
|
|
++
|
|
|
++ gp = CreatePixmap(dpy, pixmapConfig, 512, 512, &p);
|
|
|
++ DrawPixmapImage(dpy, p, 512, 512);
|
|
|
++
|
|
|
++ ctx = glXCreateContext(dpy, windowVis, NULL, True);
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Couldn't create GLX context\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXMakeCurrent(dpy, win, ctx);
|
|
|
++
|
|
|
++ BindPixmapTexture(dpy, gp);
|
|
|
++
|
|
|
++ EventLoop(dpy, win);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/wincopy.c Mesa-7.8.1.patched/progs/xdemos/wincopy.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/wincopy.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/wincopy.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,328 @@
|
|
|
++/*
|
|
|
++ * Mesa 3-D graphics library
|
|
|
++ * Version: 6.5.2
|
|
|
++ *
|
|
|
++ * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * This program opens two GLX windows, renders into one and uses
|
|
|
++ * glCopyPixels to copy the image from the first window into the
|
|
|
++ * second by means of the GLX 1.3 function glxMakeContextCurrent().
|
|
|
++ * This function works just like the glXMakeCurrentReadSGI() function
|
|
|
++ * in the GLX_SGI_make_current_read extension.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#define GL_GLEXT_PROTOTYPES
|
|
|
++#define GLX_GLXEXT_PROTOTYPES
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <unistd.h>
|
|
|
++
|
|
|
++
|
|
|
++#ifdef GLX_VERSION_1_3
|
|
|
++
|
|
|
++
|
|
|
++static Display *Dpy;
|
|
|
++static int ScrNum;
|
|
|
++static GLXContext Context;
|
|
|
++static Window Win[2]; /* Win[0] = source, Win[1] = dest */
|
|
|
++static GLint Width[2], Height[2];
|
|
|
++static GLboolean TestClipping = GL_FALSE;
|
|
|
++static GLfloat Angle = 0.0;
|
|
|
++
|
|
|
++static GLboolean DrawFront = GL_FALSE;
|
|
|
++
|
|
|
++PFNGLXMAKECURRENTREADSGIPROC make_context_current = NULL;
|
|
|
++
|
|
|
++static Window
|
|
|
++CreateWindow(Display *dpy, int scrnum, XVisualInfo *visinfo,
|
|
|
++ int xpos, int ypos, int width, int height,
|
|
|
++ const char *name)
|
|
|
++{
|
|
|
++ Window win;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++
|
|
|
++ root = RootWindow(dpy, scrnum);
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow(dpy, root, xpos, ypos, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr);
|
|
|
++ if (win) {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ }
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Redraw(void)
|
|
|
++{
|
|
|
++ /* make the first window the current one */
|
|
|
++ if (! (*make_context_current)(Dpy, Win[0], Win[0], Context)) {
|
|
|
++ printf("glXMakeContextCurrent failed in Redraw()\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ Angle += 1.0;
|
|
|
++
|
|
|
++ if (DrawFront) {
|
|
|
++ glDrawBuffer(GL_FRONT);
|
|
|
++ glReadBuffer(GL_FRONT);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glDrawBuffer(GL_BACK);
|
|
|
++ glReadBuffer(GL_BACK);
|
|
|
++ }
|
|
|
++
|
|
|
++ glViewport(0, 0, Width[0], Height[0]);
|
|
|
++ glMatrixMode(GL_PROJECTION);
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
|
|
|
++ glMatrixMode(GL_MODELVIEW);
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++ glClearColor(0.5, 0.5, 0.5, 0.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++
|
|
|
++ /* draw blue quad */
|
|
|
++ glColor3f(0.3, 0.3, 1.0);
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(Angle, 0, 0, 1);
|
|
|
++ glBegin(GL_POLYGON);
|
|
|
++ glVertex2f(-0.5, -0.25);
|
|
|
++ glVertex2f( 0.5, -0.25);
|
|
|
++ glVertex2f( 0.5, 0.25);
|
|
|
++ glVertex2f(-0.5, 0.25);
|
|
|
++ glEnd();
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++ if (DrawFront)
|
|
|
++ glFinish();
|
|
|
++ else
|
|
|
++ glXSwapBuffers(Dpy, Win[0]);
|
|
|
++
|
|
|
++
|
|
|
++ /* copy image from window 0 to window 1 */
|
|
|
++ if (!(*make_context_current)(Dpy, Win[1], Win[0], Context)) {
|
|
|
++ printf("glXMakeContextCurrent failed in Redraw()\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* copy the image between windows */
|
|
|
++ glClearColor(0.0, 0.0, 0.0, 0.0);
|
|
|
++ glClear(GL_COLOR_BUFFER_BIT);
|
|
|
++
|
|
|
++ if (TestClipping) {
|
|
|
++ glWindowPos2iARB(-2, -2);
|
|
|
++ glCopyPixels(-2, -2, Width[0] + 4, Height[0] + 4, GL_COLOR);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glWindowPos2iARB(0, 0);
|
|
|
++ glCopyPixels(0, 0, Width[0], Height[0], GL_COLOR);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (DrawFront)
|
|
|
++ glFinish();
|
|
|
++ else
|
|
|
++ glXSwapBuffers(Dpy, Win[1]);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Resize(Window win, unsigned int width, unsigned int height)
|
|
|
++{
|
|
|
++ int i;
|
|
|
++ if (win == Win[0]) {
|
|
|
++ i = 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ i = 1;
|
|
|
++ }
|
|
|
++ Width[i] = width;
|
|
|
++ Height[i] = height;
|
|
|
++ if (!glXMakeCurrent(Dpy, Win[i], Context)) {
|
|
|
++ printf("glXMakeCurrent failed in Resize()\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++EventLoop(void)
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++ while (1) {
|
|
|
++ if (XPending(Dpy) > 0) {
|
|
|
++ XNextEvent( Dpy, &event );
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ Redraw();
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ Resize(event.xany.window, event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buf[100];
|
|
|
++ KeySym keySym;
|
|
|
++ XComposeStatus stat;
|
|
|
++ XLookupString(&event.xkey, buf, sizeof(buf), &keySym, &stat);
|
|
|
++ if (keySym == XK_Escape) {
|
|
|
++ /* exit */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++ else if (buf[0] == 'f') {
|
|
|
++ DrawFront = !DrawFront;
|
|
|
++ printf("Drawing to %s buffer\n",
|
|
|
++ DrawFront ? "GL_FRONT" : "GL_BACK");
|
|
|
++ }
|
|
|
++ }
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ /*no-op*/ ;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* animate */
|
|
|
++ Redraw();
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++Init(void)
|
|
|
++{
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ int attrib[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ None };
|
|
|
++ int major, minor;
|
|
|
++
|
|
|
++ Dpy = XOpenDisplay(NULL);
|
|
|
++ if (!Dpy) {
|
|
|
++ printf("Couldn't open default display!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ ScrNum = DefaultScreen(Dpy);
|
|
|
++
|
|
|
++ glXQueryVersion(Dpy, &major, &minor);
|
|
|
++
|
|
|
++ if (major * 100 + minor >= 103) {
|
|
|
++ make_context_current = (PFNGLXMAKECURRENTREADSGIPROC)
|
|
|
++ glXGetProcAddressARB( (GLubyte *) "glXMakeContextCurrent" );
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ const char * const glxExtensions = glXQueryExtensionsString(Dpy, ScrNum);
|
|
|
++ const char * ext = strstr( glxExtensions, "GLX_SGI_make_current_read" );
|
|
|
++ const size_t len = strlen( "GLX_SGI_make_current_read" );
|
|
|
++
|
|
|
++ if ( (ext != NULL)
|
|
|
++ && ((ext[len] == ' ') || (ext[len] == '\0')) ) {
|
|
|
++ make_context_current = (PFNGLXMAKECURRENTREADSGIPROC)
|
|
|
++ glXGetProcAddressARB( (GLubyte *) "glXMakeCurrentReadSGI" );
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if (make_context_current == NULL) {
|
|
|
++ fprintf(stderr, "Sorry, this program requires either GLX 1.3 "
|
|
|
++ "or GLX_SGI_make_current_read.\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual(Dpy, ScrNum, attrib);
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Unable to find RGB, double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ Context = glXCreateContext(Dpy, visinfo, NULL, True);
|
|
|
++ if (!Context) {
|
|
|
++ printf("Couldn't create GLX context\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ Win[0] = CreateWindow(Dpy, ScrNum, visinfo,
|
|
|
++ 0, 0, 300, 300, "source window");
|
|
|
++
|
|
|
++ Win[1] = CreateWindow(Dpy, ScrNum, visinfo,
|
|
|
++ 350, 0, 300, 300, "dest window");
|
|
|
++
|
|
|
++ printf("Press Esc to exit\n");
|
|
|
++ printf("Press 'f' to toggle front/back buffer drawing\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ if (argc > 1 && strcmp(argv[1], "-clip") == 0)
|
|
|
++ TestClipping = GL_TRUE;
|
|
|
++ Init();
|
|
|
++ EventLoop();
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++#else
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ printf("This program requires GLX 1.3!\n");
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++#endif /* GLX_VERSION_1_3 */
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/xdemo.c Mesa-7.8.1.patched/progs/xdemos/xdemo.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/xdemo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/xdemo.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,334 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * Very simple demo of how to use the Mesa/X11 interface instead of the
|
|
|
++ * glx, tk or aux toolkits. I highly recommend using the GLX interface
|
|
|
++ * instead of the X/Mesa interface, however.
|
|
|
++ *
|
|
|
++ * This program is in the public domain.
|
|
|
++ *
|
|
|
++ * Brian Paul
|
|
|
++ */
|
|
|
++
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/Xutil.h>
|
|
|
++#include "GL/xmesa.h"
|
|
|
++#include "GL/gl.h"
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static GLint Black, Red, Green, Blue;
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void make_window( char *title, int color_flag )
|
|
|
++{
|
|
|
++ int x = 10, y = 10, width = 400, height = 300;
|
|
|
++ Display *dpy;
|
|
|
++ int scr;
|
|
|
++ Window root, win;
|
|
|
++ Colormap cmap;
|
|
|
++ XColor xcolor;
|
|
|
++ int attr_flags;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ XTextProperty tp;
|
|
|
++ XSizeHints sh;
|
|
|
++ XEvent e;
|
|
|
++ XMesaContext context;
|
|
|
++ XMesaVisual visual;
|
|
|
++ XMesaBuffer buffer;
|
|
|
++
|
|
|
++
|
|
|
++ /*
|
|
|
++ * Do the usual X things to make a window.
|
|
|
++ */
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Couldn't open default display!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ scr = DefaultScreen(dpy);
|
|
|
++ root = RootWindow(dpy, scr);
|
|
|
++
|
|
|
++ /* alloc visinfo struct */
|
|
|
++ visinfo = (XVisualInfo *) malloc( sizeof(XVisualInfo) );
|
|
|
++
|
|
|
++ /* Get a visual and colormap */
|
|
|
++ if (color_flag) {
|
|
|
++ /* Open TrueColor window */
|
|
|
++
|
|
|
++/*
|
|
|
++ if (!XMatchVisualInfo( dpy, scr, 24, TrueColor, visinfo )) {
|
|
|
++ printf("Couldn't get 24-bit TrueColor visual!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++*/
|
|
|
++ if (!XMatchVisualInfo( dpy, scr, 8, PseudoColor, visinfo )) {
|
|
|
++ printf("Couldn't get 8-bit PseudoColor visual!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ cmap = XCreateColormap( dpy, root, visinfo->visual, AllocNone );
|
|
|
++ Black = Red = Green = Blue = 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* Open color index window */
|
|
|
++
|
|
|
++ if (!XMatchVisualInfo( dpy, scr, 8, PseudoColor, visinfo )) {
|
|
|
++ printf("Couldn't get 8-bit PseudoColor visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ cmap = XCreateColormap( dpy, root, visinfo->visual, AllocNone );
|
|
|
++
|
|
|
++ /* Allocate colors */
|
|
|
++ xcolor.red = 0x0;
|
|
|
++ xcolor.green = 0x0;
|
|
|
++ xcolor.blue = 0x0;
|
|
|
++ xcolor.flags = DoRed | DoGreen | DoBlue;
|
|
|
++ if (!XAllocColor( dpy, cmap, &xcolor )) {
|
|
|
++ printf("Couldn't allocate black!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ Black = xcolor.pixel;
|
|
|
++
|
|
|
++ xcolor.red = 0xffff;
|
|
|
++ xcolor.green = 0x0;
|
|
|
++ xcolor.blue = 0x0;
|
|
|
++ xcolor.flags = DoRed | DoGreen | DoBlue;
|
|
|
++ if (!XAllocColor( dpy, cmap, &xcolor )) {
|
|
|
++ printf("Couldn't allocate red!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ Red = xcolor.pixel;
|
|
|
++
|
|
|
++ xcolor.red = 0x0;
|
|
|
++ xcolor.green = 0xffff;
|
|
|
++ xcolor.blue = 0x0;
|
|
|
++ xcolor.flags = DoRed | DoGreen | DoBlue;
|
|
|
++ if (!XAllocColor( dpy, cmap, &xcolor )) {
|
|
|
++ printf("Couldn't allocate green!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ Green = xcolor.pixel;
|
|
|
++
|
|
|
++ xcolor.red = 0x0;
|
|
|
++ xcolor.green = 0x0;
|
|
|
++ xcolor.blue = 0xffff;
|
|
|
++ xcolor.flags = DoRed | DoGreen | DoBlue;
|
|
|
++ if (!XAllocColor( dpy, cmap, &xcolor )) {
|
|
|
++ printf("Couldn't allocate blue!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ Blue = xcolor.pixel;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* set window attributes */
|
|
|
++ attr.colormap = cmap;
|
|
|
++ attr.event_mask = ExposureMask | StructureNotifyMask;
|
|
|
++ attr.border_pixel = BlackPixel( dpy, scr );
|
|
|
++ attr.background_pixel = BlackPixel( dpy, scr );
|
|
|
++ attr_flags = CWColormap | CWEventMask | CWBorderPixel | CWBackPixel;
|
|
|
++
|
|
|
++ /* Create the window */
|
|
|
++ win = XCreateWindow( dpy, root, x,y, width, height, 0,
|
|
|
++ visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual,
|
|
|
++ attr_flags, &attr);
|
|
|
++ if (!win) {
|
|
|
++ printf("Couldn't open window!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XStringListToTextProperty(&title, 1, &tp);
|
|
|
++ sh.flags = USPosition | USSize;
|
|
|
++ XSetWMProperties(dpy, win, &tp, &tp, 0, 0, &sh, 0, 0);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ while (1) {
|
|
|
++ XNextEvent( dpy, &e );
|
|
|
++ if (e.type == MapNotify && e.xmap.window == win) {
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ /*
|
|
|
++ * Now do the special Mesa/Xlib stuff!
|
|
|
++ */
|
|
|
++
|
|
|
++ visual = XMesaCreateVisual( dpy, visinfo,
|
|
|
++ (GLboolean) color_flag,
|
|
|
++ GL_FALSE, /* alpha_flag */
|
|
|
++ GL_FALSE, /* db_flag */
|
|
|
++ GL_FALSE, /* stereo flag */
|
|
|
++ GL_FALSE, /* ximage_flag */
|
|
|
++ 0, /* depth size */
|
|
|
++ 0, /* stencil size */
|
|
|
++ 0,0,0,0, /* accum_size */
|
|
|
++ 0, /* num samples */
|
|
|
++ 0, /* level */
|
|
|
++ 0 /* caveat */
|
|
|
++ );
|
|
|
++ if (!visual) {
|
|
|
++ printf("Couldn't create Mesa/X visual!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Create a Mesa rendering context */
|
|
|
++ context = XMesaCreateContext( visual,
|
|
|
++ NULL /* share_list */
|
|
|
++ );
|
|
|
++ if (!context) {
|
|
|
++ printf("Couldn't create Mesa/X context!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ buffer = XMesaCreateWindowBuffer( visual, win );
|
|
|
++ if (!buffer) {
|
|
|
++ printf("Couldn't create Mesa/X buffer!\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ XMesaMakeCurrent( context, buffer );
|
|
|
++
|
|
|
++ /* Ready to render! */
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void draw_cube( void )
|
|
|
++{
|
|
|
++ /* X faces */
|
|
|
++ glIndexi( Red );
|
|
|
++ glColor3f( 1.0, 0.0, 0.0 );
|
|
|
++ glBegin( GL_POLYGON );
|
|
|
++ glVertex3f( 1.0, 1.0, 1.0 );
|
|
|
++ glVertex3f( 1.0, -1.0, 1.0 );
|
|
|
++ glVertex3f( 1.0, -1.0, -1.0 );
|
|
|
++ glVertex3f( 1.0, 1.0, -1.0 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glBegin( GL_POLYGON );
|
|
|
++ glVertex3f( -1.0, 1.0, 1.0 );
|
|
|
++ glVertex3f( -1.0, 1.0, -1.0 );
|
|
|
++ glVertex3f( -1.0, -1.0, -1.0 );
|
|
|
++ glVertex3f( -1.0, -1.0, 1.0 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* Y faces */
|
|
|
++ glIndexi( Green );
|
|
|
++ glColor3f( 0.0, 1.0, 0.0 );
|
|
|
++ glBegin( GL_POLYGON );
|
|
|
++ glVertex3f( 1.0, 1.0, 1.0 );
|
|
|
++ glVertex3f( 1.0, 1.0, -1.0 );
|
|
|
++ glVertex3f( -1.0, 1.0, -1.0 );
|
|
|
++ glVertex3f( -1.0, 1.0, 1.0 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glBegin( GL_POLYGON );
|
|
|
++ glVertex3f( 1.0, -1.0, 1.0 );
|
|
|
++ glVertex3f( -1.0, -1.0, 1.0 );
|
|
|
++ glVertex3f( -1.0, -1.0, -1.0 );
|
|
|
++ glVertex3f( 1.0, -1.0, -1.0 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* Z faces */
|
|
|
++ glIndexi( Blue );
|
|
|
++ glColor3f( 0.0, 0.0, 1.0 );
|
|
|
++ glBegin( GL_POLYGON );
|
|
|
++ glVertex3f( 1.0, 1.0, 1.0 );
|
|
|
++ glVertex3f( -1.0, 1.0, 1.0 );
|
|
|
++ glVertex3f( -1.0, -1.0, 1.0 );
|
|
|
++ glVertex3f( 1.0, -1.0, 1.0 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ glBegin( GL_POLYGON );
|
|
|
++ glVertex3f( 1.0, 1.0, -1.0 );
|
|
|
++ glVertex3f( 1.0,-1.0, -1.0 );
|
|
|
++ glVertex3f( -1.0,-1.0, -1.0 );
|
|
|
++ glVertex3f( -1.0, 1.0, -1.0 );
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void display_loop( void )
|
|
|
++{
|
|
|
++ GLfloat xrot, yrot, zrot;
|
|
|
++
|
|
|
++ xrot = yrot = zrot = 0.0;
|
|
|
++
|
|
|
++ glClearColor( 0.0, 0.0, 0.0, 0.0 );
|
|
|
++ glClearIndex( Black );
|
|
|
++
|
|
|
++ glMatrixMode( GL_PROJECTION );
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum( -1.0, 1.0, -1.0, 1.0, 1.0, 10.0 );
|
|
|
++ glTranslatef( 0.0, 0.0, -5.0 );
|
|
|
++
|
|
|
++ glMatrixMode( GL_MODELVIEW );
|
|
|
++ glLoadIdentity();
|
|
|
++
|
|
|
++ glCullFace( GL_BACK );
|
|
|
++ glEnable( GL_CULL_FACE );
|
|
|
++
|
|
|
++ glShadeModel( GL_FLAT );
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ glClear( GL_COLOR_BUFFER_BIT );
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef( xrot, 1.0, 0.0, 0.0 );
|
|
|
++ glRotatef( yrot, 0.0, 1.0, 0.0 );
|
|
|
++ glRotatef( zrot, 0.0, 0.0, 1.0 );
|
|
|
++
|
|
|
++ draw_cube();
|
|
|
++
|
|
|
++ glPopMatrix();
|
|
|
++ glFinish();
|
|
|
++
|
|
|
++ xrot += 10.0;
|
|
|
++ yrot += 7.0;
|
|
|
++ zrot -= 3.0;
|
|
|
++ }
|
|
|
++
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int main( int argc, char *argv[] )
|
|
|
++{
|
|
|
++ int mode = 0;
|
|
|
++
|
|
|
++ if (argc >= 2)
|
|
|
++ {
|
|
|
++ if (strcmp(argv[1],"-ci")==0)
|
|
|
++ mode = 0;
|
|
|
++ else if (strcmp(argv[1],"-rgb")==0)
|
|
|
++ mode = 1;
|
|
|
++ else
|
|
|
++ {
|
|
|
++ printf("Bad flag: %s\n", argv[1]);
|
|
|
++ printf("Specify -ci for 8-bit color index or -rgb for RGB mode\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else
|
|
|
++ {
|
|
|
++ printf("Specify -ci for 8-bit color index or -rgb for RGB mode\n");
|
|
|
++ printf("Defaulting to 8-bit color index\n");
|
|
|
++ }
|
|
|
++
|
|
|
++ make_window( argv[0], mode );
|
|
|
++
|
|
|
++ display_loop();
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/xfont.c Mesa-7.8.1.patched/progs/xdemos/xfont.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/xfont.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/xfont.c 2010-06-13 13:45:06.788792936 +0200
|
|
|
+@@ -0,0 +1,206 @@
|
|
|
++
|
|
|
++/*
|
|
|
++ * Mesa 3-D graphics library
|
|
|
++ *
|
|
|
++ * Copyright (C) 1999 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Example of using glXUseXFont().
|
|
|
++ * 5 November 1999
|
|
|
++ * Brian Paul
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++
|
|
|
++
|
|
|
++static const char *ProgramName = "xfont";
|
|
|
++
|
|
|
++static const char *FontName = "fixed";
|
|
|
++
|
|
|
++static GLuint FontBase = 0;
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void redraw( Display *dpy, Window w )
|
|
|
++{
|
|
|
++ static const char *text = "This is glXUseXFont()";
|
|
|
++
|
|
|
++ glClear( GL_COLOR_BUFFER_BIT );
|
|
|
++
|
|
|
++ /* triangle */
|
|
|
++ glColor3f( 0.2, 0.2, 1.0 );
|
|
|
++ glBegin(GL_TRIANGLES);
|
|
|
++ glVertex2f( 0, 0.8 );
|
|
|
++ glVertex2f( -0.8, -0.7 );
|
|
|
++ glVertex2f( 0.8, -0.7 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* text */
|
|
|
++ glColor3f( 1, 1, 1 );
|
|
|
++ glRasterPos2f(-0.8, 0);
|
|
|
++ glListBase(FontBase);
|
|
|
++ glCallLists(strlen(text), GL_UNSIGNED_BYTE, (GLubyte *) text);
|
|
|
++
|
|
|
++ glXSwapBuffers( dpy, w );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void resize( unsigned int width, unsigned int height )
|
|
|
++{
|
|
|
++ glViewport( 0, 0, width, height );
|
|
|
++ glMatrixMode( GL_PROJECTION );
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho( -1.0, 1.0, -1.0, 1.0, -1.0, 1.0 );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void setup_font( Display *dpy )
|
|
|
++{
|
|
|
++ XFontStruct *fontInfo;
|
|
|
++ Font id;
|
|
|
++ unsigned int first, last;
|
|
|
++
|
|
|
++ fontInfo = XLoadQueryFont(dpy, FontName);
|
|
|
++ if (!fontInfo) {
|
|
|
++ printf("Error: font %s not found\n", FontName);
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++
|
|
|
++ id = fontInfo->fid;
|
|
|
++ first = fontInfo->min_char_or_byte2;
|
|
|
++ last = fontInfo->max_char_or_byte2;
|
|
|
++
|
|
|
++ FontBase = glGenLists((GLuint) last + 1);
|
|
|
++ if (!FontBase) {
|
|
|
++ printf("Error: unable to allocate display lists\n");
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++ glXUseXFont(id, first, last - first + 1, FontBase + first);
|
|
|
++}
|
|
|
++
|
|
|
++static Window make_rgb_db_window( Display *dpy, int xpos, int ypos,
|
|
|
++ 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;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attrib );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, ProgramName, ProgramName,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++
|
|
|
++ glXMakeCurrent( dpy, win, ctx );
|
|
|
++
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void event_loop( Display *dpy )
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ XNextEvent( dpy, &event );
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ redraw( dpy, event.xany.window );
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ resize( event.xconfigure.width, event.xconfigure.height );
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ exit(0);
|
|
|
++ default:
|
|
|
++ ; /* no-op */
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int main( int argc, char *argv[] )
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++
|
|
|
++ win = make_rgb_db_window( dpy, 0, 0, 300, 300 );
|
|
|
++ setup_font( dpy );
|
|
|
++
|
|
|
++ glShadeModel( GL_FLAT );
|
|
|
++ glClearColor( 0.5, 0.5, 1.0, 1.0 );
|
|
|
++
|
|
|
++ XMapWindow( dpy, win );
|
|
|
++
|
|
|
++ event_loop( dpy );
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/xrotfontdemo.c Mesa-7.8.1.patched/progs/xdemos/xrotfontdemo.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/xrotfontdemo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/xrotfontdemo.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,220 @@
|
|
|
++/*
|
|
|
++ * Mesa 3-D graphics library
|
|
|
++ *
|
|
|
++ * Copyright (C) 1999 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Example of using glXUseRotatedXFontMESA().
|
|
|
++ * 24 Jan 2004
|
|
|
++ * Brian Paul
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <GL/gl.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include "xuserotfont.h"
|
|
|
++
|
|
|
++
|
|
|
++static const char *ProgramName = "xfont";
|
|
|
++
|
|
|
++static const char *FontName = "fixed";
|
|
|
++
|
|
|
++static GLuint FontBase[4];
|
|
|
++
|
|
|
++
|
|
|
++static void redraw( Display *dpy, Window w )
|
|
|
++{
|
|
|
++ static const char *text = " Rotated bitmap text";
|
|
|
++ int i;
|
|
|
++
|
|
|
++ glClear( GL_COLOR_BUFFER_BIT );
|
|
|
++
|
|
|
++ /* triangle */
|
|
|
++ glColor3f( 0.2, 0.2, 1.0 );
|
|
|
++ glBegin(GL_TRIANGLES);
|
|
|
++ glVertex2f( -0.8, 0.7 );
|
|
|
++ glVertex2f( -0.8, -0.7 );
|
|
|
++ glVertex2f( 0.8, 0.0 );
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* marker */
|
|
|
++ glColor3f( 0, 1, 0 );
|
|
|
++ glBegin(GL_POINTS);
|
|
|
++ glVertex2f(0, 0);
|
|
|
++ glEnd();
|
|
|
++
|
|
|
++ /* text */
|
|
|
++ glColor3f( 1, 1, 1 );
|
|
|
++
|
|
|
++ for (i = 0; i < 4; i++) {
|
|
|
++ glRasterPos2f(0, 0);
|
|
|
++ glListBase(FontBase[i]);
|
|
|
++ glCallLists(strlen(text), GL_UNSIGNED_BYTE, (GLubyte *) text);
|
|
|
++ }
|
|
|
++
|
|
|
++ glXSwapBuffers( dpy, w );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void resize( unsigned int width, unsigned int height )
|
|
|
++{
|
|
|
++ glViewport( 0, 0, width, height );
|
|
|
++ glMatrixMode( GL_PROJECTION );
|
|
|
++ glLoadIdentity();
|
|
|
++ glOrtho( -1.0, 1.0, -1.0, 1.0, -1.0, 1.0 );
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++static void setup_font( Display *dpy )
|
|
|
++{
|
|
|
++ XFontStruct *fontInfo;
|
|
|
++ Font id;
|
|
|
++ unsigned int first, last;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ fontInfo = XLoadQueryFont(dpy, FontName);
|
|
|
++ if (!fontInfo) {
|
|
|
++ printf("Error: font %s not found\n", FontName);
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++
|
|
|
++ id = fontInfo->fid;
|
|
|
++ first = fontInfo->min_char_or_byte2;
|
|
|
++ last = fontInfo->max_char_or_byte2;
|
|
|
++
|
|
|
++ for (i = 0; i < 4; i++) {
|
|
|
++ FontBase[i] = glGenLists((GLuint) last + 1);
|
|
|
++ if (!FontBase[i]) {
|
|
|
++ printf("Error: unable to allocate display lists\n");
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++ glXUseRotatedXFontMESA(id, first, last - first + 1, FontBase[i] + first,
|
|
|
++ i * 90);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static Window make_rgb_db_window( Display *dpy, int xpos, int ypos,
|
|
|
++ 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;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attrib );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = xpos;
|
|
|
++ sizehints.y = ypos;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, ProgramName, ProgramName,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++
|
|
|
++ glXMakeCurrent( dpy, win, ctx );
|
|
|
++
|
|
|
++ return win;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void event_loop( Display *dpy )
|
|
|
++{
|
|
|
++ XEvent event;
|
|
|
++
|
|
|
++ while (1) {
|
|
|
++ XNextEvent( dpy, &event );
|
|
|
++
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ redraw( dpy, event.xany.window );
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ resize( event.xconfigure.width, event.xconfigure.height );
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ exit(0);
|
|
|
++ default:
|
|
|
++ ; /* no-op */
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++
|
|
|
++int main( int argc, char *argv[] )
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(NULL);
|
|
|
++
|
|
|
++ win = make_rgb_db_window( dpy, 0, 0, 300, 300 );
|
|
|
++ setup_font( dpy );
|
|
|
++
|
|
|
++ glShadeModel( GL_FLAT );
|
|
|
++ glClearColor( 0.5, 0.5, 1.0, 1.0 );
|
|
|
++
|
|
|
++ XMapWindow( dpy, win );
|
|
|
++
|
|
|
++ event_loop( dpy );
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/xuserotfont.c Mesa-7.8.1.patched/progs/xdemos/xuserotfont.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/xuserotfont.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/xuserotfont.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,399 @@
|
|
|
++/*
|
|
|
++ * Mesa 3-D graphics library
|
|
|
++ * Version: 6.1
|
|
|
++ *
|
|
|
++ * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/* \file xuserotfont.c
|
|
|
++ *
|
|
|
++ * A function like glXUseXFont() but takes a 0, 90, 180 or 270 degree
|
|
|
++ * rotation angle for rotated text display.
|
|
|
++ *
|
|
|
++ * Based on Mesa's glXUseXFont implementation written by Thorsten Ohl.
|
|
|
++ */
|
|
|
++
|
|
|
++#include <assert.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <GL/glx.h>
|
|
|
++#include "xuserotfont.h"
|
|
|
++
|
|
|
++
|
|
|
++/**
|
|
|
++ * Generate OpenGL-compatible bitmap by drawing an X character glyph
|
|
|
++ * to an off-screen pixmap, then getting the image and testing pixels.
|
|
|
++ * \param width bitmap width in pixels
|
|
|
++ * \param height bitmap height in pixels
|
|
|
++ */
|
|
|
++static void
|
|
|
++fill_bitmap(Display *dpy, Pixmap pixmap, GC gc,
|
|
|
++ unsigned int bitmapWidth, unsigned int bitmapHeight,
|
|
|
++ unsigned int charWidth, unsigned int charHeight,
|
|
|
++ int xPos, int yPos, unsigned int c, GLubyte * bitmap,
|
|
|
++ int rotation)
|
|
|
++{
|
|
|
++ const int bytesPerRow = (bitmapWidth + 7) / 8;
|
|
|
++ XImage *image;
|
|
|
++ XChar2b char2b;
|
|
|
++
|
|
|
++ /* clear pixmap to 0 */
|
|
|
++ XSetForeground(dpy, gc, 0);
|
|
|
++ XFillRectangle(dpy, pixmap, gc, 0, 0, charWidth, charHeight);
|
|
|
++
|
|
|
++ /* The glyph is drawn snug up against the left/top edges of the pixmap */
|
|
|
++ XSetForeground(dpy, gc, 1);
|
|
|
++ char2b.byte1 = (c >> 8) & 0xff;
|
|
|
++ char2b.byte2 = (c & 0xff);
|
|
|
++ XDrawString16(dpy, pixmap, gc, xPos, yPos, &char2b, 1);
|
|
|
++
|
|
|
++ /* initialize GL bitmap */
|
|
|
++ memset(bitmap, 0, bytesPerRow * bitmapHeight);
|
|
|
++
|
|
|
++ image = XGetImage(dpy, pixmap, 0, 0, charWidth, charHeight, 1, XYPixmap);
|
|
|
++ if (image) {
|
|
|
++ /* Set appropriate bits in the GL bitmap.
|
|
|
++ * Note: X11 and OpenGL are upside down wrt each other).
|
|
|
++ */
|
|
|
++ unsigned int x, y;
|
|
|
++ if (rotation == 0) {
|
|
|
++ for (y = 0; y < charHeight; y++) {
|
|
|
++ for (x = 0; x < charWidth; x++) {
|
|
|
++ if (XGetPixel(image, x, y)) {
|
|
|
++ int y2 = bitmapHeight - y - 1;
|
|
|
++ bitmap[bytesPerRow * y2 + x / 8] |= (1 << (7 - (x % 8)));
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else if (rotation == 90) {
|
|
|
++ for (y = 0; y < charHeight; y++) {
|
|
|
++ for (x = 0; x < charWidth; x++) {
|
|
|
++ if (XGetPixel(image, x, y)) {
|
|
|
++ int x2 = y;
|
|
|
++ int y2 = x;
|
|
|
++ bitmap[bytesPerRow * y2 + x2 / 8] |= (1 << (7 - (x2 % 8)));
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else if (rotation == 180) {
|
|
|
++ for (y = 0; y < charHeight; y++) {
|
|
|
++ for (x = 0; x < charWidth; x++) {
|
|
|
++ if (XGetPixel(image, x, y)) {
|
|
|
++ int x2 = charWidth - x - 1;
|
|
|
++ bitmap[bytesPerRow * y + x2 / 8] |= (1 << (7 - (x2 % 8)));
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ assert(rotation == 270);
|
|
|
++ for (y = 0; y < charHeight; y++) {
|
|
|
++ for (x = 0; x < charWidth; x++) {
|
|
|
++ if (XGetPixel(image, x, y)) {
|
|
|
++ int x2 = charHeight - y - 1;
|
|
|
++ int y2 = charWidth - x - 1;
|
|
|
++ bitmap[bytesPerRow * y2 + x2 / 8] |= (1 << (7 - (x2 % 8)));
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ XDestroyImage(image);
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Determine if a given glyph is valid and return the
|
|
|
++ * corresponding XCharStruct.
|
|
|
++ */
|
|
|
++static const XCharStruct *
|
|
|
++isvalid(const XFontStruct * fs, unsigned int which)
|
|
|
++{
|
|
|
++ unsigned int rows, pages;
|
|
|
++ unsigned int byte1 = 0, byte2 = 0;
|
|
|
++ int i, valid = 1;
|
|
|
++
|
|
|
++ rows = fs->max_byte1 - fs->min_byte1 + 1;
|
|
|
++ pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
|
|
|
++
|
|
|
++ if (rows == 1) {
|
|
|
++ /* "linear" fonts */
|
|
|
++ if ((fs->min_char_or_byte2 > which) || (fs->max_char_or_byte2 < which))
|
|
|
++ valid = 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* "matrix" fonts */
|
|
|
++ byte2 = which & 0xff;
|
|
|
++ byte1 = which >> 8;
|
|
|
++ if ((fs->min_char_or_byte2 > byte2) ||
|
|
|
++ (fs->max_char_or_byte2 < byte2) ||
|
|
|
++ (fs->min_byte1 > byte1) || (fs->max_byte1 < byte1))
|
|
|
++ valid = 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (valid) {
|
|
|
++ if (fs->per_char) {
|
|
|
++ if (rows == 1) {
|
|
|
++ /* "linear" fonts */
|
|
|
++ return fs->per_char + (which - fs->min_char_or_byte2);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* "matrix" fonts */
|
|
|
++ i = ((byte1 - fs->min_byte1) * pages) +
|
|
|
++ (byte2 - fs->min_char_or_byte2);
|
|
|
++ return fs->per_char + i;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ return &fs->min_bounds;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void
|
|
|
++glXUseRotatedXFontMESA(Font font, int first, int count, int listbase,
|
|
|
++ int rotation)
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ Pixmap pixmap;
|
|
|
++ GC gc;
|
|
|
++ XFontStruct *fs;
|
|
|
++ GLint swapbytes, lsbfirst, rowlength;
|
|
|
++ GLint skiprows, skippixels, alignment;
|
|
|
++ unsigned int maxCharWidth, maxCharHeight;
|
|
|
++ GLubyte *bm;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ if (rotation != 0 &&
|
|
|
++ rotation != 90 &&
|
|
|
++ rotation != 180 &&
|
|
|
++ rotation != 270)
|
|
|
++ return;
|
|
|
++
|
|
|
++ dpy = glXGetCurrentDisplay();
|
|
|
++ if (!dpy)
|
|
|
++ return; /* I guess glXMakeCurrent wasn't called */
|
|
|
++ win = RootWindow(dpy, DefaultScreen(dpy));
|
|
|
++
|
|
|
++ fs = XQueryFont(dpy, font);
|
|
|
++ if (!fs) {
|
|
|
++ /*
|
|
|
++ _mesa_error(NULL, GL_INVALID_VALUE,
|
|
|
++ "Couldn't get font structure information");
|
|
|
++ */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Allocate a GL bitmap that can fit any character */
|
|
|
++ maxCharWidth = fs->max_bounds.rbearing - fs->min_bounds.lbearing;
|
|
|
++ maxCharHeight = fs->max_bounds.ascent + fs->max_bounds.descent;
|
|
|
++ /* use max, in case we're rotating */
|
|
|
++ if (rotation == 90 || rotation == 270) {
|
|
|
++ /* swap width/height */
|
|
|
++ bm = (GLubyte *) malloc((maxCharHeight + 7) / 8 * maxCharWidth);
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ /* normal or upside down */
|
|
|
++ bm = (GLubyte *) malloc((maxCharWidth + 7) / 8 * maxCharHeight);
|
|
|
++ }
|
|
|
++ if (!bm) {
|
|
|
++ XFreeFontInfo(NULL, fs, 1);
|
|
|
++ /*
|
|
|
++ _mesa_error(NULL, GL_OUT_OF_MEMORY,
|
|
|
++ "Couldn't allocate bitmap in glXUseXFont()");
|
|
|
++ */
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++#if 0
|
|
|
++ /* get the page info */
|
|
|
++ pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
|
|
|
++ firstchar = (fs->min_byte1 << 8) + fs->min_char_or_byte2;
|
|
|
++ lastchar = (fs->max_byte1 << 8) + fs->max_char_or_byte2;
|
|
|
++ rows = fs->max_byte1 - fs->min_byte1 + 1;
|
|
|
++ unsigned int first_char, last_char, pages, rows;
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* Save the current packing mode for bitmaps. */
|
|
|
++ glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes);
|
|
|
++ glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst);
|
|
|
++ glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength);
|
|
|
++ glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows);
|
|
|
++ glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);
|
|
|
++ glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
|
|
|
++
|
|
|
++ /* Enforce a standard packing mode which is compatible with
|
|
|
++ fill_bitmap() from above. This is actually the default mode,
|
|
|
++ except for the (non)alignment. */
|
|
|
++ glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
|
|
|
++ glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
|
|
|
++ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
|
++ glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
|
|
|
++ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
|
|
|
++ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
++
|
|
|
++ /* Create pixmap and GC */
|
|
|
++ pixmap = XCreatePixmap(dpy, win, maxCharWidth, maxCharHeight, 1);
|
|
|
++ {
|
|
|
++ XGCValues values;
|
|
|
++ unsigned long valuemask;
|
|
|
++ values.foreground = BlackPixel(dpy, DefaultScreen(dpy));
|
|
|
++ values.background = WhitePixel(dpy, DefaultScreen(dpy));
|
|
|
++ values.font = fs->fid;
|
|
|
++ valuemask = GCForeground | GCBackground | GCFont;
|
|
|
++ gc = XCreateGC(dpy, pixmap, valuemask, &values);
|
|
|
++ }
|
|
|
++
|
|
|
++#ifdef DEBUG_XROT
|
|
|
++ if (debug_xfonts)
|
|
|
++ dump_font_struct(fs);
|
|
|
++#endif
|
|
|
++
|
|
|
++ for (i = 0; i < count; i++) {
|
|
|
++ const unsigned int c = first + i;
|
|
|
++ const int list = listbase + i;
|
|
|
++ unsigned int charWidth, charHeight;
|
|
|
++ unsigned int bitmapWidth = 0, bitmapHeight = 0;
|
|
|
++ GLfloat xOrig, yOrig, xStep, yStep, dtemp;
|
|
|
++ const XCharStruct *ch;
|
|
|
++ int xPos, yPos;
|
|
|
++ int valid;
|
|
|
++
|
|
|
++ /* check on index validity and get the bounds */
|
|
|
++ ch = isvalid(fs, c);
|
|
|
++ if (!ch) {
|
|
|
++ ch = &fs->max_bounds;
|
|
|
++ valid = 0;
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ valid = 1;
|
|
|
++ }
|
|
|
++
|
|
|
++#ifdef DEBUG_XROT
|
|
|
++ if (debug_xfonts) {
|
|
|
++ char s[7];
|
|
|
++ sprintf(s, isprint(c) ? "%c> " : "\\%03o> ", c);
|
|
|
++ dump_char_struct(ch, s);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* glBitmap()' parameters:
|
|
|
++ straight from the glXUseXFont(3) manpage. */
|
|
|
++ charWidth = ch->rbearing - ch->lbearing;
|
|
|
++ charHeight = ch->ascent + ch->descent;
|
|
|
++ xOrig = -ch->lbearing;
|
|
|
++ yOrig = ch->descent;
|
|
|
++ xStep = ch->width;
|
|
|
++ yStep = 0;
|
|
|
++
|
|
|
++ /* X11's starting point. */
|
|
|
++ xPos = -ch->lbearing;
|
|
|
++ yPos = ch->ascent;
|
|
|
++
|
|
|
++ /* Apply rotation */
|
|
|
++ switch (rotation) {
|
|
|
++ case 0:
|
|
|
++ /* nothing */
|
|
|
++ bitmapWidth = charWidth;
|
|
|
++ bitmapHeight = charHeight;
|
|
|
++ break;
|
|
|
++ case 90:
|
|
|
++ /* xStep, yStep */
|
|
|
++ dtemp = xStep;
|
|
|
++ xStep = -yStep;
|
|
|
++ yStep = dtemp;
|
|
|
++ /* xOrig, yOrig */
|
|
|
++ yOrig = xOrig;
|
|
|
++ xOrig = charHeight - (charHeight - yPos);
|
|
|
++ /* width, height */
|
|
|
++ bitmapWidth = charHeight;
|
|
|
++ bitmapHeight = charWidth;
|
|
|
++ break;
|
|
|
++ case 180:
|
|
|
++ /* xStep, yStep */
|
|
|
++ xStep = -xStep;
|
|
|
++ yStep = -yStep;
|
|
|
++ /* xOrig, yOrig */
|
|
|
++ xOrig = charWidth - xOrig - 1;
|
|
|
++ yOrig = charHeight - yOrig - 1;
|
|
|
++ bitmapWidth = charWidth;
|
|
|
++ bitmapHeight = charHeight;
|
|
|
++ break;
|
|
|
++ case 270:
|
|
|
++ /* xStep, yStep */
|
|
|
++ dtemp = xStep;
|
|
|
++ xStep = yStep;
|
|
|
++ yStep = -dtemp;
|
|
|
++ /* xOrig, yOrig */
|
|
|
++ dtemp = yOrig;
|
|
|
++ yOrig = charWidth - xOrig;
|
|
|
++ xOrig = dtemp;
|
|
|
++ /* width, height */
|
|
|
++ bitmapWidth = charHeight;
|
|
|
++ bitmapHeight = charWidth;
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ /* should never get here */
|
|
|
++ ;
|
|
|
++ }
|
|
|
++
|
|
|
++ glNewList(list, GL_COMPILE);
|
|
|
++ if (valid && bitmapWidth > 0 && bitmapHeight > 0) {
|
|
|
++
|
|
|
++ fill_bitmap(dpy, pixmap, gc, bitmapWidth, bitmapHeight,
|
|
|
++ charWidth, charHeight,
|
|
|
++ xPos, yPos, c, bm, rotation);
|
|
|
++
|
|
|
++ glBitmap(bitmapWidth, bitmapHeight, xOrig, yOrig, xStep, yStep, bm);
|
|
|
++
|
|
|
++#ifdef DEBUG_XROT
|
|
|
++ if (debug_xfonts) {
|
|
|
++ printf("width/height = %u/%u\n", bitmapWidth, bitmapHeight);
|
|
|
++ dump_bitmap(bitmapWidth, bitmapHeight, bm);
|
|
|
++ }
|
|
|
++#endif
|
|
|
++ }
|
|
|
++ else {
|
|
|
++ glBitmap(0, 0, 0.0, 0.0, xStep, yStep, NULL);
|
|
|
++ }
|
|
|
++ glEndList();
|
|
|
++ }
|
|
|
++
|
|
|
++ free(bm);
|
|
|
++ XFreeFontInfo(NULL, fs, 1);
|
|
|
++ XFreePixmap(dpy, pixmap);
|
|
|
++ XFreeGC(dpy, gc);
|
|
|
++
|
|
|
++ /* Restore saved packing modes. */
|
|
|
++ glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
|
|
|
++ glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
|
|
|
++ glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
|
|
|
++ glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
|
|
|
++ glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
|
|
|
++ glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/xuserotfont.h Mesa-7.8.1.patched/progs/xdemos/xuserotfont.h
|
|
|
+--- Mesa-7.8.1/progs/xdemos/xuserotfont.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/xuserotfont.h 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,12 @@
|
|
|
++#ifndef XUSEROTFONT_H
|
|
|
++#define XUSEROTFONT_H
|
|
|
++
|
|
|
++#include <X11/Xlib.h>
|
|
|
++
|
|
|
++
|
|
|
++extern void
|
|
|
++glXUseRotatedXFontMESA(Font font, int first, int count, int listbase,
|
|
|
++ int rotation);
|
|
|
++
|
|
|
++
|
|
|
++#endif
|
|
|
+diff -Naurp Mesa-7.8.1/progs/xdemos/yuvrect_client.c Mesa-7.8.1.patched/progs/xdemos/yuvrect_client.c
|
|
|
+--- Mesa-7.8.1/progs/xdemos/yuvrect_client.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
++++ Mesa-7.8.1.patched/progs/xdemos/yuvrect_client.c 2010-06-13 13:45:06.789793146 +0200
|
|
|
+@@ -0,0 +1,326 @@
|
|
|
++/*
|
|
|
++ * Test the GL_NV_texture_rectangle and GL_MESA_ycrcb_texture extensions and GLX_MESA_allocate-memory
|
|
|
++ *
|
|
|
++ * Dave Airlie - Feb 2005
|
|
|
++ */
|
|
|
++
|
|
|
++#include <assert.h>
|
|
|
++#include <math.h>
|
|
|
++#include <stdio.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <string.h>
|
|
|
++#include <X11/Xlib.h>
|
|
|
++#include <X11/keysym.h>
|
|
|
++#define GL_GLEXT_PROTOTYPES
|
|
|
++#include <GL/glx.h>
|
|
|
++
|
|
|
++#include "../util/readtex.c" /* I know, this is a hack. */
|
|
|
++
|
|
|
++#define TEXTURE_FILE "../images/girl2.rgb"
|
|
|
++
|
|
|
++static GLfloat Xrot = 0, Yrot = 0, Zrot = 0;
|
|
|
++static GLint ImgWidth, ImgHeight;
|
|
|
++static GLushort *ImageYUV = NULL;
|
|
|
++static void *glx_memory;
|
|
|
++
|
|
|
++static void DrawObject(void)
|
|
|
++{
|
|
|
++ glBegin(GL_QUADS);
|
|
|
++
|
|
|
++ glTexCoord2f(0, 0);
|
|
|
++ glVertex2f(-1.0, -1.0);
|
|
|
++
|
|
|
++ glTexCoord2f(ImgWidth, 0);
|
|
|
++ glVertex2f(1.0, -1.0);
|
|
|
++
|
|
|
++ glTexCoord2f(ImgWidth, ImgHeight);
|
|
|
++ glVertex2f(1.0, 1.0);
|
|
|
++
|
|
|
++ glTexCoord2f(0, ImgHeight);
|
|
|
++ glVertex2f(-1.0, 1.0);
|
|
|
++
|
|
|
++ glEnd();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void scr_Display( void )
|
|
|
++{
|
|
|
++ glClear( GL_COLOR_BUFFER_BIT );
|
|
|
++
|
|
|
++ glPushMatrix();
|
|
|
++ glRotatef(Xrot, 1.0, 0.0, 0.0);
|
|
|
++ glRotatef(Yrot, 0.0, 1.0, 0.0);
|
|
|
++ glRotatef(Zrot, 0.0, 0.0, 1.0);
|
|
|
++ DrawObject();
|
|
|
++ glPopMatrix();
|
|
|
++
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void Reshape( int width, int height )
|
|
|
++{
|
|
|
++ glViewport( 0, 0, width, height );
|
|
|
++ glMatrixMode( GL_PROJECTION );
|
|
|
++ glLoadIdentity();
|
|
|
++ glFrustum( -1.0, 1.0, -1.0, 1.0, 10.0, 100.0 );
|
|
|
++ glMatrixMode( GL_MODELVIEW );
|
|
|
++ glLoadIdentity();
|
|
|
++ glTranslatef( 0.0, 0.0, -15.0 );
|
|
|
++}
|
|
|
++
|
|
|
++static int queryClient(Display *dpy, int screen)
|
|
|
++{
|
|
|
++#ifdef GLX_MESA_allocate_memory
|
|
|
++ char *extensions;
|
|
|
++
|
|
|
++ extensions = (char *)glXQueryExtensionsString(dpy, screen);
|
|
|
++ if (!extensions || !strstr(extensions,"GLX_MESA_allocate_memory")) {
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ return 1;
|
|
|
++#else
|
|
|
++ return 0;
|
|
|
++#endif
|
|
|
++}
|
|
|
++
|
|
|
++static int
|
|
|
++query_extension(char* extName) {
|
|
|
++ char *p = (char *) glGetString(GL_EXTENSIONS);
|
|
|
++ char *end = p + strlen(p);
|
|
|
++ while (p < end) {
|
|
|
++ int n = strcspn(p, " ");
|
|
|
++ if ((strlen(extName) == n) && (strncmp(extName, p, n) == 0))
|
|
|
++ return GL_TRUE;
|
|
|
++ p += (n + 1);
|
|
|
++ }
|
|
|
++ return GL_FALSE;
|
|
|
++}
|
|
|
++
|
|
|
++static void Init( int argc, char *argv[] , Display *dpy, int screen, Window win)
|
|
|
++{
|
|
|
++ GLuint texObj = 100;
|
|
|
++ const char *file;
|
|
|
++ void *glx_memory;
|
|
|
++
|
|
|
++ if (!query_extension("GL_NV_texture_rectangle")) {
|
|
|
++ printf("Sorry, GL_NV_texture_rectangle is required\n");
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!query_extension("GL_MESA_ycbcr_texture")) {
|
|
|
++ printf("Sorry, GL_MESA_ycbcr_texture is required\n");
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!queryClient(dpy, screen)) {
|
|
|
++ printf("Sorry, GLX_MESA_allocate_memory is required\n");
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, 1);
|
|
|
++ glBindTexture(GL_TEXTURE_RECTANGLE_NV, texObj);
|
|
|
++#ifdef LINEAR_FILTER
|
|
|
++ /* linear filtering looks much nicer but is much slower for Mesa */
|
|
|
++ glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
++ glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
++#else
|
|
|
++ glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
++ glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
++#endif
|
|
|
++
|
|
|
++ if (argc > 1)
|
|
|
++ file = argv[1];
|
|
|
++ else
|
|
|
++ file = TEXTURE_FILE;
|
|
|
++
|
|
|
++ ImageYUV = LoadYUVImage(file, &ImgWidth, &ImgHeight);
|
|
|
++ if (!ImageYUV) {
|
|
|
++ printf("Couldn't read %s\n", TEXTURE_FILE);
|
|
|
++ exit(0);
|
|
|
++ }
|
|
|
++
|
|
|
++ glx_memory = glXAllocateMemoryMESA(dpy, screen, ImgWidth * ImgHeight * 2, 0, 0 ,0);
|
|
|
++ if (!glx_memory)
|
|
|
++ {
|
|
|
++ fprintf(stderr,"Failed to allocate MESA memory\n");
|
|
|
++ exit(-1);
|
|
|
++ }
|
|
|
++
|
|
|
++ memcpy(glx_memory, ImageYUV, ImgWidth * ImgHeight * 2);
|
|
|
++
|
|
|
++ printf("Image: %dx%d\n", ImgWidth, ImgHeight);
|
|
|
++
|
|
|
++ glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0,
|
|
|
++ GL_YCBCR_MESA, ImgWidth, ImgHeight, 0,
|
|
|
++ GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_APPLE, glx_memory);
|
|
|
++
|
|
|
++ assert(glGetError() == GL_NO_ERROR);
|
|
|
++
|
|
|
++ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
|
++
|
|
|
++ glEnable(GL_TEXTURE_RECTANGLE_NV);
|
|
|
++
|
|
|
++ glShadeModel(GL_FLAT);
|
|
|
++ glClearColor(0.3, 0.3, 0.4, 1.0);
|
|
|
++
|
|
|
++}
|
|
|
++
|
|
|
++/*
|
|
|
++ * Create an RGB, double-buffered window.
|
|
|
++ * Return the window and context handles.
|
|
|
++ */
|
|
|
++static void
|
|
|
++make_window( Display *dpy, const char *name,
|
|
|
++ int x, int y, int width, int height,
|
|
|
++ Window *winRet, GLXContext *ctxRet)
|
|
|
++{
|
|
|
++ int attribs[] = { GLX_RGBA,
|
|
|
++ GLX_RED_SIZE, 1,
|
|
|
++ GLX_GREEN_SIZE, 1,
|
|
|
++ GLX_BLUE_SIZE, 1,
|
|
|
++ GLX_DOUBLEBUFFER,
|
|
|
++ GLX_DEPTH_SIZE, 1,
|
|
|
++ None };
|
|
|
++ int scrnum;
|
|
|
++ XSetWindowAttributes attr;
|
|
|
++ unsigned long mask;
|
|
|
++ Window root;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ XVisualInfo *visinfo;
|
|
|
++
|
|
|
++ scrnum = DefaultScreen( dpy );
|
|
|
++ root = RootWindow( dpy, scrnum );
|
|
|
++
|
|
|
++ visinfo = glXChooseVisual( dpy, scrnum, attribs );
|
|
|
++ if (!visinfo) {
|
|
|
++ printf("Error: couldn't get an RGB, Double-buffered visual\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* window attributes */
|
|
|
++ attr.background_pixel = 0;
|
|
|
++ attr.border_pixel = 0;
|
|
|
++ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
|
|
|
++ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
|
|
|
++ attr.override_redirect = 0;
|
|
|
++ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect;
|
|
|
++
|
|
|
++ win = XCreateWindow( dpy, root, 0, 0, width, height,
|
|
|
++ 0, visinfo->depth, InputOutput,
|
|
|
++ visinfo->visual, mask, &attr );
|
|
|
++
|
|
|
++ /* set hints and properties */
|
|
|
++ {
|
|
|
++ XSizeHints sizehints;
|
|
|
++ sizehints.x = x;
|
|
|
++ sizehints.y = y;
|
|
|
++ sizehints.width = width;
|
|
|
++ sizehints.height = height;
|
|
|
++ sizehints.flags = USSize | USPosition;
|
|
|
++ XSetNormalHints(dpy, win, &sizehints);
|
|
|
++ XSetStandardProperties(dpy, win, name, name,
|
|
|
++ None, (char **)NULL, 0, &sizehints);
|
|
|
++ }
|
|
|
++
|
|
|
++ ctx = glXCreateContext( dpy, visinfo, NULL, True );
|
|
|
++ if (!ctx) {
|
|
|
++ printf("Error: glXCreateContext failed\n");
|
|
|
++ exit(1);
|
|
|
++ }
|
|
|
++
|
|
|
++ XFree(visinfo);
|
|
|
++
|
|
|
++ *winRet = win;
|
|
|
++ *ctxRet = ctx;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void
|
|
|
++event_loop(Display *dpy, Window win)
|
|
|
++{
|
|
|
++ while (1) {
|
|
|
++ while (XPending(dpy) > 0) {
|
|
|
++ XEvent event;
|
|
|
++ XNextEvent(dpy, &event);
|
|
|
++ switch (event.type) {
|
|
|
++ case Expose:
|
|
|
++ /* we'll redraw below */
|
|
|
++ break;
|
|
|
++ case ConfigureNotify:
|
|
|
++ Reshape(event.xconfigure.width, event.xconfigure.height);
|
|
|
++ break;
|
|
|
++ case KeyPress:
|
|
|
++ {
|
|
|
++ char buffer[10];
|
|
|
++ int r, code;
|
|
|
++ code = XLookupKeysym(&event.xkey, 0);
|
|
|
++ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
|
|
|
++ NULL, NULL);
|
|
|
++ if (buffer[0] == 27) {
|
|
|
++ /* escape */
|
|
|
++ return;
|
|
|
++
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++int
|
|
|
++main(int argc, char *argv[])
|
|
|
++{
|
|
|
++ Display *dpy;
|
|
|
++ Window win;
|
|
|
++ GLXContext ctx;
|
|
|
++ char *dpyName = NULL;
|
|
|
++ GLboolean printInfo = GL_FALSE;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ for (i = 1; i < argc; i++) {
|
|
|
++ if (strcmp(argv[i], "-display") == 0) {
|
|
|
++ dpyName = argv[i+1];
|
|
|
++ i++;
|
|
|
++ }
|
|
|
++ else if (strcmp(argv[i], "-info") == 0) {
|
|
|
++ printInfo = GL_TRUE;
|
|
|
++ }
|
|
|
++ else
|
|
|
++ printf("Warrning: unknown parameter: %s\n", argv[i]);
|
|
|
++ }
|
|
|
++
|
|
|
++ dpy = XOpenDisplay(dpyName);
|
|
|
++ if (!dpy) {
|
|
|
++ printf("Error: couldn't open display %s\n",
|
|
|
++ XDisplayName(dpyName));
|
|
|
++ return -1;
|
|
|
++ }
|
|
|
++
|
|
|
++ make_window(dpy, "yuvrect_client", 0, 0, 300, 300, &win, &ctx);
|
|
|
++ XMapWindow(dpy, win);
|
|
|
++ glXMakeCurrent(dpy, win, ctx);
|
|
|
++
|
|
|
++ if (printInfo) {
|
|
|
++ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
|
|
|
++ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
|
|
|
++ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
|
|
|
++ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
|
|
|
++ }
|
|
|
++
|
|
|
++ Init(argc, argv, dpy, DefaultScreen(dpy), win);
|
|
|
++
|
|
|
++ scr_Display();
|
|
|
++ glXSwapBuffers(dpy, win);
|
|
|
++ event_loop(dpy, win);
|
|
|
++
|
|
|
++ glXFreeMemoryMESA(dpy, DefaultScreen(dpy), glx_memory);
|
|
|
++ glXDestroyContext(dpy, ctx);
|
|
|
++ XDestroyWindow(dpy, win);
|
|
|
++ XCloseDisplay(dpy);
|
|
|
++
|
|
|
++ return 0;
|
|
|
++}
|
Waldemar Brodkorb