1
2/* Copyright (c) Mark J. Kilgard, 1997. */
3
4/* This program is freely distributable without licensing fees
5   and is provided without guarantee or warrantee expressed or
6   implied. This program is -not- in the public domain. */
7
8#include <stdlib.h>
9#include <string.h>
10#include "glutint.h"
11
12#if defined(GLX_VERSION_1_1)
13int
14__glutIsSupportedByGLX(char *extension)
15{
16  static const char *extensions = NULL;
17  const char *start;
18  char *where, *terminator;
19  int major, minor;
20
21  glXQueryVersion(__glutDisplay, &major, &minor);
22  /* Be careful not to call glXQueryExtensionsString if it
23     looks like the server doesn't support GLX 1.1.
24     Unfortunately, the original GLX 1.0 didn't have the notion
25     of GLX extensions. */
26  if ((major == 1 && minor >= 1) || (major > 1)) {
27    if (!extensions)
28      extensions = glXQueryExtensionsString(__glutDisplay, __glutScreen);
29    /* It takes a bit of care to be fool-proof about parsing
30       the GLX extensions string.  Don't be fooled by
31       sub-strings,  etc. */
32    start = extensions;
33    for (;;) {
34      where = strstr(start, extension);
35      if (!where)
36        return 0;
37      terminator = where + strlen(extension);
38      if (where == start || *(where - 1) == ' ') {
39        if (*terminator == ' ' || *terminator == '\0') {
40          return 1;
41        }
42      }
43      start = terminator;
44    }
45  }
46  return 0;
47}
48#endif
49
50
51
52/*
53 * Wrapping of GLX extension functions.
54 * Technically, we should do a runtime test to see if we've got the
55 * glXGetProcAddressARB() function.  I think GLX_ARB_get_proc_address
56 * is pretty widely supported now and any system that has
57 * GLX_ARB_get_proc_address defined in its header files should be OK
58 * at runtime.
59 */
60
61int
62__glut_glXBindChannelToWindowSGIX(Display *dpy, int screen,
63                                  int channel, Window window)
64{
65#ifdef GLX_ARB_get_proc_address
66  typedef int (*glXBindChannelToWindowSGIX_t) (Display *, int, int, Window);
67  static glXBindChannelToWindowSGIX_t glXBindChannelToWindowSGIX_ptr = NULL;
68  if (!glXBindChannelToWindowSGIX_ptr) {
69    glXBindChannelToWindowSGIX_ptr = (glXBindChannelToWindowSGIX_t)
70      glXGetProcAddressARB((const GLubyte *) "glXBindChannelToWindowSGIX");
71  }
72  if (glXBindChannelToWindowSGIX_ptr)
73    return (*glXBindChannelToWindowSGIX_ptr)(dpy, screen, channel, window);
74  else
75    return 0;
76#elif defined(GLX_SGIX_video_resize)
77  return glXBindChannelToWindowSGIX(dpy, screen, channel, window);
78#else
79  return 0;
80#endif
81}
82
83
84int
85__glut_glXChannelRectSGIX(Display *dpy, int screen, int channel,
86                          int x, int y, int w, int h)
87{
88#ifdef GLX_ARB_get_proc_address
89  typedef int (*glXChannelRectSGIX_t)(Display *, int, int, int, int, int, int);
90  static glXChannelRectSGIX_t glXChannelRectSGIX_ptr = NULL;
91  if (!glXChannelRectSGIX_ptr) {
92    glXChannelRectSGIX_ptr = (glXChannelRectSGIX_t)
93      glXGetProcAddressARB((const GLubyte *) "glXChannelRectSGIX");
94  }
95  if (glXChannelRectSGIX_ptr)
96    return (*glXChannelRectSGIX_ptr)(dpy, screen, channel, x, y, w, h);
97  else
98    return 0;
99#elif defined(GLX_SGIX_video_resize)
100  return glXChannelRectSGIX(dpy, screen, channel, x, y, w, h);
101#else
102  return 0;
103#endif
104}
105
106
107int
108__glut_glXQueryChannelRectSGIX(Display *dpy, int screen, int channel,
109                               int *x, int *y, int *w, int *h)
110{
111#ifdef GLX_ARB_get_proc_address
112  typedef int (*glXQueryChannelRectSGIX_t)(Display *, int, int,
113                                           int *, int *, int *, int *);
114  static glXQueryChannelRectSGIX_t glXQueryChannelRectSGIX_ptr = NULL;
115  if (!glXQueryChannelRectSGIX_ptr) {
116    glXQueryChannelRectSGIX_ptr = (glXQueryChannelRectSGIX_t)
117      glXGetProcAddressARB((const GLubyte *) "glXQueryChannelRectSGIX");
118  }
119  if (glXQueryChannelRectSGIX_ptr)
120    return (*glXQueryChannelRectSGIX_ptr)(dpy, screen, channel, x, y, w, h);
121  else
122    return 0;
123#elif defined(GLX_SGIX_video_resize)
124  return glXQueryChannelRectSGIX(dpy, screen, channel, x, y, w, h);
125#else
126  return 0;
127#endif
128}
129
130
131int
132__glut_glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel,
133                                 int *dx, int *dy, int *dw, int *dh)
134{
135#ifdef GLX_ARB_get_proc_address
136  typedef int (*glXQueryChannelDeltasSGIX_t)(Display *, int, int,
137                                             int *, int *, int *, int *);
138  static glXQueryChannelDeltasSGIX_t glXQueryChannelDeltasSGIX_ptr = NULL;
139  if (!glXQueryChannelDeltasSGIX_ptr) {
140    glXQueryChannelDeltasSGIX_ptr = (glXQueryChannelDeltasSGIX_t)
141      glXGetProcAddressARB((const GLubyte *) "glXQueryChannelDeltasSGIX");
142  }
143  if (glXQueryChannelDeltasSGIX_ptr)
144    return (*glXQueryChannelDeltasSGIX_ptr)(dpy, screen, channel,
145                                            dx, dy, dw, dh);
146  else
147    return 0;
148#elif defined(GLX_SGIX_video_resize)
149  return glXQueryChannelDeltasSGIX(dpy, screen, channel, dx, dy, dw, dh);
150#else
151  return 0;
152#endif
153}
154
155
156int
157__glut_glXChannelRectSyncSGIX(Display *dpy, int screen,
158                              int channel, GLenum synctype)
159{
160#ifdef GLX_ARB_get_proc_address
161  typedef int (*glXChannelRectSyncSGIX_t)(Display *, int, int, GLenum);
162  static glXChannelRectSyncSGIX_t glXChannelRectSyncSGIX_ptr = NULL;
163  if (!glXChannelRectSyncSGIX_ptr) {
164    glXChannelRectSyncSGIX_ptr = (glXChannelRectSyncSGIX_t)
165      glXGetProcAddressARB((const GLubyte *) "glXChannelRectSyncSGIX");
166  }
167  if (glXChannelRectSyncSGIX_ptr)
168    return (*glXChannelRectSyncSGIX_ptr)(dpy, screen, channel, synctype);
169  else
170    return 0;
171#elif defined(GLX_SGIX_video_resize)
172  return glXChannelRectSyncSGIX(dpy, screen, channel, synctype);
173#else
174  return 0;
175#endif
176}
177
178
179
180GLXContext
181__glut_glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config,
182                                      int render_type, GLXContext share_list,
183                                      Bool direct)
184{
185#ifdef GLX_ARB_get_proc_address
186  typedef GLXContext (*glXCreateContextWithConfigSGIX_t)(Display *,
187                                 GLXFBConfigSGIX, int, GLXContext, Bool);
188  static glXCreateContextWithConfigSGIX_t glXCreateContextWithConfig_ptr = NULL;
189  if (!glXCreateContextWithConfig_ptr) {
190    glXCreateContextWithConfig_ptr = (glXCreateContextWithConfigSGIX_t)
191       glXGetProcAddressARB((const GLubyte *) "glXCreateContextWithConfigSGIX");
192  }
193  if (glXCreateContextWithConfig_ptr)
194    return (*glXCreateContextWithConfig_ptr)(dpy, config, render_type,
195                                             share_list, direct);
196  else
197    return 0;
198#elif defined(GLX_SGIX_fbconfig)
199  return glXCreateContextWithConfigSGIX(dpy, config, render_type,
200                                        share_list, direct);
201#else
202  return 0;
203#endif
204}
205
206
207int
208__glut_glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config,
209                                int attribute, int *value)
210{
211#ifdef GLX_ARB_get_proc_address
212  typedef int (*glXGetFBConfigAttribSGIX_t)(Display *,
213                                            GLXFBConfigSGIX, int, int *);
214  static glXGetFBConfigAttribSGIX_t glXGetFBConfigAttrib_ptr = NULL;
215  if (!glXGetFBConfigAttrib_ptr) {
216    glXGetFBConfigAttrib_ptr = (glXGetFBConfigAttribSGIX_t)
217       glXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttribSGIX");
218  }
219  if (glXGetFBConfigAttrib_ptr)
220    return (*glXGetFBConfigAttrib_ptr)(dpy, config, attribute, value);
221  else
222    return 0;
223#elif defined(GLX_SGIX_fbconfig)
224  return glXGetFBConfigAttribSGIX(dpy, config, attribute, value);
225#else
226  return 0;
227#endif
228}
229
230
231GLXFBConfigSGIX
232__glut_glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
233{
234#ifdef GLX_ARB_get_proc_address
235  typedef GLXFBConfigSGIX (*glXGetFBConfigFromVisualSGIX_t)(Display *,
236                                                            XVisualInfo *);
237  static glXGetFBConfigFromVisualSGIX_t glXGetFBConfigFromVisual_ptr = NULL;
238  if (!glXGetFBConfigFromVisual_ptr) {
239    glXGetFBConfigFromVisual_ptr = (glXGetFBConfigFromVisualSGIX_t)
240       glXGetProcAddressARB((const GLubyte *) "glXGetFBConfigFromVisualSGIX");
241  }
242  if (glXGetFBConfigFromVisual_ptr)
243    return (*glXGetFBConfigFromVisual_ptr)(dpy, vis);
244  else
245    return 0;
246#elif defined(GLX_SGIX_fbconfig)
247  return glXGetFBConfigFromVisualSGIX(dpy, vis);
248#else
249  return 0;
250#endif
251}
252
253
254
255
256