← Back to branch summary

~ubuntu-branches/ubuntu/karmic/virtualbox-ose/karmic-updates

« back to all changes in this revision

Viewing changes to src/VBox/Additions/x11/x11include/glproto-1.4.9/GL/internal/glcore.h

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-09-14 18:25:07 UTC
  • mfrom: (0.4.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090914182507-c98g07mq16hjmn6d
Tags: 3.0.6-dfsg-1ubuntu1
https://launchpad.net/bugs/429697
https://launchpad.net/bugs/267097
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/379878
* Merge from debian unstable (LP: #429697), remaining changes:
  - Enable DKMS support on virtualbox host and guest modules (LP: #267097)
    - Drop virtualbox-ose{-guest,}-modules-* package templates
    - Recommend *-source instead of *-modules packages
    - Replace error messages related to missing/mismatched
      kernel module accordingly
  - Autoload kernel module
    - LOAD_VBOXDRV_MODULE=1 in virtualbox-ose.default
  - Disable update action
    - patches/u01-disable-update-action.dpatch
  - Virtualbox should go in Accessories, not in System tools (LP: #288590)
    - virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add apport hook
    - virtualbox-ose.files/source_virtualbox-ose.py
    - virtualbox-ose.install
  - Add launchpad integration
    - control
    - lpi-bug.xpm
    - patches/u02-lp-integration.dpatch
  - virtualbox, virtualbox-* (names of the upstream proprietary packages)
    conflict with virtualbox-ose (LP: #379878)
* Make debug package depend on normal or guest utils package
* Drop patches/22-pulseaudio-stubs.dpatch (applied upstream)
* Rename Ubuntu specific patches to uXX-*.dpatch
* Fix lintian warnings in maintainer scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Additions/x11/x11include/glproto-1.4.9/GL/internal/glcore.h
1
 
/* $XFree86: xc/lib/GL/include/GL/internal/glcore.h,v 1.7 2001/03/25 05:32:00 tsi Exp $ */
2
 
#ifndef __gl_core_h_
3
 
#define __gl_core_h_
4
 
 
5
 
/*
6
 
** License Applicability. Except to the extent portions of this file are
7
 
** made subject to an alternative license as permitted in the SGI Free
8
 
** Software License B, Version 1.1 (the "License"), the contents of this
9
 
** file are subject only to the provisions of the License. You may not use
10
 
** this file except in compliance with the License. You may obtain a copy
11
 
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
12
 
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
13
 
** 
14
 
** http://oss.sgi.com/projects/FreeB
15
 
** 
16
 
** Note that, as provided in the License, the Software is distributed on an
17
 
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
18
 
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
19
 
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
20
 
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
21
 
** 
22
 
** Original Code. The Original Code is: OpenGL Sample Implementation,
23
 
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
24
 
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
25
 
** Copyright in any portions created by third parties is as indicated
26
 
** elsewhere herein. All Rights Reserved.
27
 
** 
28
 
** Additional Notice Provisions: The application programming interfaces
29
 
** established by SGI in conjunction with the Original Code are The
30
 
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
31
 
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
32
 
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
33
 
** Window System(R) (Version 1.3), released October 19, 1998. This software
34
 
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
35
 
** published by SGI, but has not been independently verified as being
36
 
** compliant with the OpenGL(R) version 1.2.1 Specification.
37
 
**
38
 
*/
39
 
 
40
 
#ifndef XFree86LOADER
41
 
#include <sys/types.h>
42
 
#endif
43
 
 
44
 
#ifdef CAPI
45
 
#undef CAPI
46
 
#endif
47
 
#define CAPI
48
 
 
49
 
#define GL_CORE_SGI  1
50
 
#define GL_CORE_MESA 2
51
 
#define GL_CORE_APPLE 4
52
 
#define GL_CORE_WINDOWS 8
53
 
 
54
 
typedef struct __GLcontextRec __GLcontext;
55
 
typedef struct __GLinterfaceRec __GLinterface;
56
 
 
57
 
/*
58
 
** This file defines the interface between the GL core and the surrounding
59
 
** "operating system" that supports it (currently the GLX or WGL extensions).
60
 
**
61
 
** Members (data and function pointers) are documented as imported or
62
 
** exported according to how they are used by the core rendering functions.
63
 
** Imported members are initialized by the "operating system" and used by
64
 
** the core functions.  Exported members are initialized by the core functions
65
 
** and used by the "operating system".
66
 
*/
67
 
 
68
 
/*
69
 
** Mode and limit information for a context.  This information is
70
 
** kept around in the context so that values can be used during
71
 
** command execution, and for returning information about the
72
 
** context to the application.
73
 
*/
74
 
typedef struct __GLcontextModesRec {
75
 
    struct __GLcontextModesRec * next;
76
 
 
77
 
    GLboolean rgbMode;
78
 
    GLboolean floatMode;
79
 
    GLboolean colorIndexMode;
80
 
    GLuint doubleBufferMode;
81
 
    GLuint stereoMode;
82
 
 
83
 
    GLboolean haveAccumBuffer;
84
 
    GLboolean haveDepthBuffer;
85
 
    GLboolean haveStencilBuffer;
86
 
 
87
 
    GLint redBits, greenBits, blueBits, alphaBits;      /* bits per comp */
88
 
    GLuint redMask, greenMask, blueMask, alphaMask;
89
 
    GLint rgbBits;              /* total bits for rgb */
90
 
    GLint indexBits;            /* total bits for colorindex */
91
 
 
92
 
    GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
93
 
    GLint depthBits;
94
 
    GLint stencilBits;
95
 
 
96
 
    GLint numAuxBuffers;
97
 
 
98
 
    GLint level;
99
 
 
100
 
    GLint pixmapMode;
101
 
 
102
 
    /* GLX */
103
 
    GLint visualID;
104
 
    GLint visualType;     /**< One of the GLX X visual types. (i.e., 
105
 
                           * \c GLX_TRUE_COLOR, etc.)
106
 
                           */
107
 
 
108
 
    /* EXT_visual_rating / GLX 1.2 */
109
 
    GLint visualRating;
110
 
 
111
 
    /* EXT_visual_info / GLX 1.2 */
112
 
    GLint transparentPixel;
113
 
                                /*    colors are floats scaled to ints */
114
 
    GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;
115
 
    GLint transparentIndex;
116
 
 
117
 
    /* ARB_multisample / SGIS_multisample */
118
 
    GLint sampleBuffers;
119
 
    GLint samples;
120
 
 
121
 
    /* SGIX_fbconfig / GLX 1.3 */
122
 
    GLint drawableType;
123
 
    GLint renderType;
124
 
    GLint xRenderable;
125
 
    GLint fbconfigID;
126
 
 
127
 
    /* SGIX_pbuffer / GLX 1.3 */
128
 
    GLint maxPbufferWidth;
129
 
    GLint maxPbufferHeight;
130
 
    GLint maxPbufferPixels;
131
 
    GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */
132
 
    GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */
133
 
 
134
 
    /* SGIX_visual_select_group */
135
 
    GLint visualSelectGroup;
136
 
 
137
 
    /* OML_swap_method */
138
 
    GLint swapMethod;
139
 
 
140
 
    GLint screen;
141
 
} __GLcontextModes;
142
 
 
143
 
/* Several fields of __GLcontextModes can take these as values.  Since
144
 
 * GLX header files may not be available everywhere they need to be used,
145
 
 * redefine them here.
146
 
 */
147
 
#define GLX_NONE                           0x8000
148
 
#define GLX_SLOW_CONFIG                    0x8001
149
 
#define GLX_TRUE_COLOR                     0x8002
150
 
#define GLX_DIRECT_COLOR                   0x8003
151
 
#define GLX_PSEUDO_COLOR                   0x8004
152
 
#define GLX_STATIC_COLOR                   0x8005
153
 
#define GLX_GRAY_SCALE                     0x8006
154
 
#define GLX_STATIC_GRAY                    0x8007
155
 
#define GLX_TRANSPARENT_RGB                0x8008
156
 
#define GLX_TRANSPARENT_INDEX              0x8009
157
 
#define GLX_NON_CONFORMANT_CONFIG          0x800D
158
 
#define GLX_SWAP_EXCHANGE_OML              0x8061
159
 
#define GLX_SWAP_COPY_OML                  0x8062
160
 
#define GLX_SWAP_UNDEFINED_OML             0x8063
161
 
 
162
 
#define GLX_DONT_CARE                      0xFFFFFFFF
163
 
 
164
 
#define GLX_RGBA_BIT                       0x00000001
165
 
#define GLX_COLOR_INDEX_BIT                0x00000002
166
 
#define GLX_WINDOW_BIT                     0x00000001
167
 
#define GLX_PIXMAP_BIT                     0x00000002
168
 
#define GLX_PBUFFER_BIT                    0x00000004
169
 
 
170
 
/************************************************************************/
171
 
 
172
 
/*
173
 
** Structure used for allocating and freeing drawable private memory.
174
 
** (like software buffers, for example).
175
 
**
176
 
** The memory allocation routines are provided by the surrounding
177
 
** "operating system" code, and they are to be used for allocating
178
 
** software buffers and things which are associated with the drawable,
179
 
** and used by any context which draws to that drawable.  There are
180
 
** separate memory allocation functions for drawables and contexts
181
 
** since drawables and contexts can be created and destroyed independently
182
 
** of one another, and the "operating system" may want to use separate
183
 
** allocation arenas for each.
184
 
**
185
 
** The freePrivate function is filled in by the core routines when they
186
 
** allocates software buffers, and stick them in "private".  The freePrivate
187
 
** function will destroy anything allocated to this drawable (to be called
188
 
** when the drawable is destroyed).
189
 
*/
190
 
typedef struct __GLdrawableRegionRec __GLdrawableRegion;
191
 
typedef struct __GLdrawableBufferRec __GLdrawableBuffer;
192
 
typedef struct __GLdrawablePrivateRec __GLdrawablePrivate;
193
 
 
194
 
typedef struct __GLregionRectRec {
195
 
    /* lower left (inside the rectangle) */
196
 
    GLint x0, y0;
197
 
    /* upper right (outside the rectangle) */
198
 
    GLint x1, y1;
199
 
} __GLregionRect;
200
 
 
201
 
struct __GLdrawableRegionRec {
202
 
    GLint numRects;
203
 
    __GLregionRect *rects;
204
 
    __GLregionRect boundingRect;
205
 
};
206
 
 
207
 
/************************************************************************/
208
 
 
209
 
/* masks for the buffers */
210
 
#define __GL_FRONT_BUFFER_MASK          0x00000001
211
 
#define __GL_FRONT_LEFT_BUFFER_MASK     0x00000001
212
 
#define __GL_FRONT_RIGHT_BUFFER_MASK    0x00000002
213
 
#define __GL_BACK_BUFFER_MASK           0x00000004
214
 
#define __GL_BACK_LEFT_BUFFER_MASK      0x00000004
215
 
#define __GL_BACK_RIGHT_BUFFER_MASK     0x00000008
216
 
#define __GL_ACCUM_BUFFER_MASK          0x00000010
217
 
#define __GL_DEPTH_BUFFER_MASK          0x00000020
218
 
#define __GL_STENCIL_BUFFER_MASK        0x00000040
219
 
#define __GL_AUX_BUFFER_MASK(i)         (0x0000080 << (i))
220
 
 
221
 
#define __GL_ALL_BUFFER_MASK            0xffffffff
222
 
 
223
 
/* what Resize routines return if resize resorted to fallback case */
224
 
#define __GL_BUFFER_FALLBACK    0x10
225
 
 
226
 
typedef void (*__GLbufFallbackInitFn)(__GLdrawableBuffer *buf, 
227
 
                                      __GLdrawablePrivate *glPriv, GLint bits);
228
 
typedef void (*__GLbufMainInitFn)(__GLdrawableBuffer *buf, 
229
 
                                  __GLdrawablePrivate *glPriv, GLint bits,
230
 
                                  __GLbufFallbackInitFn back);
231
 
 
232
 
/*
233
 
** A drawable buffer
234
 
**
235
 
** This data structure describes the context side of a drawable.  
236
 
**
237
 
** According to the spec there could be multiple contexts bound to the same
238
 
** drawable at the same time (from different threads).  In order to avoid
239
 
** multiple-access conflicts, locks are used to serialize access.  When a
240
 
** thread needs to access (read or write) a member of the drawable, it takes
241
 
** a lock first.  Some of the entries in the drawable are treated "mostly
242
 
** constant", so we take the freedom of allowing access to them without
243
 
** taking a lock (for optimization reasons).
244
 
**
245
 
** For more details regarding locking, see buffers.h in the GL core
246
 
*/
247
 
struct __GLdrawableBufferRec {
248
 
    /*
249
 
    ** Buffer dimensions
250
 
    */
251
 
    GLint width, height, depth;
252
 
 
253
 
    /*
254
 
    ** Framebuffer base address
255
 
    */
256
 
    void *base;
257
 
 
258
 
    /*
259
 
    ** Framebuffer size (in bytes)
260
 
    */
261
 
    GLuint size;
262
 
 
263
 
    /*
264
 
    ** Size (in bytes) of each element in the framebuffer
265
 
    */
266
 
    GLuint elementSize;
267
 
    GLuint elementSizeLog2;
268
 
 
269
 
    /*
270
 
    ** Element skip from one scanline to the next.
271
 
    ** If the buffer is part of another buffer (for example, fullscreen
272
 
    ** front buffer), outerWidth is the width of that buffer.
273
 
    */
274
 
    GLint outerWidth;
275
 
 
276
 
    /*
277
 
    ** outerWidth * elementSize
278
 
    */
279
 
    GLint byteWidth;
280
 
 
281
 
    /*
282
 
    ** Allocation/deallocation is done based on this handle.  A handle
283
 
    ** is conceptually different from the framebuffer 'base'.
284
 
    */
285
 
    void *handle;
286
 
 
287
 
    /* imported */
288
 
    GLboolean (*resize)(__GLdrawableBuffer *buf,
289
 
                        GLint x, GLint y, GLuint width, GLuint height, 
290
 
                        __GLdrawablePrivate *glPriv, GLuint bufferMask);
291
 
    void (*lock)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv);
292
 
    void (*unlock)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv);
293
 
    void (*fill)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv,
294
 
                GLuint val, GLint x, GLint y, GLint w, GLint h);
295
 
    void (*free)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv);
296
 
 
297
 
    /* exported */
298
 
    void (*freePrivate)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv);
299
 
#ifdef __cplusplus
300
 
    void *privatePtr;
301
 
#else
302
 
    void *private;
303
 
#endif
304
 
 
305
 
    /* private */
306
 
    void *other;        /* implementation private data */
307
 
    __GLbufMainInitFn mainInit;
308
 
    __GLbufFallbackInitFn fallbackInit;
309
 
};
310
 
 
311
 
/*
312
 
** The context side of the drawable private
313
 
*/
314
 
struct __GLdrawablePrivateRec {
315
 
    /*
316
 
    ** Drawable Modes
317
 
    */
318
 
    __GLcontextModes *modes;
319
 
 
320
 
    /*
321
 
    ** Drawable size
322
 
    */
323
 
    GLuint width, height;
324
 
 
325
 
    /*
326
 
    ** Origin in screen coordinates of the drawable
327
 
    */
328
 
    GLint xOrigin, yOrigin;
329
 
#ifdef __GL_ALIGNED_BUFFERS
330
 
    /*
331
 
    ** Drawable offset from screen origin
332
 
    */
333
 
    GLint xOffset, yOffset;
334
 
 
335
 
    /*
336
 
    ** Alignment restriction
337
 
    */
338
 
    GLint xAlignment, yAlignment;
339
 
#endif
340
 
    /*
341
 
    ** Should we invert the y axis?
342
 
    */
343
 
    GLint yInverted;
344
 
 
345
 
    /*
346
 
    ** Mask specifying which buffers are renderable by the hw
347
 
    */
348
 
    GLuint accelBufferMask;
349
 
 
350
 
    /*
351
 
    ** the buffers themselves
352
 
    */
353
 
    __GLdrawableBuffer frontBuffer;
354
 
    __GLdrawableBuffer backBuffer;
355
 
    __GLdrawableBuffer accumBuffer;
356
 
    __GLdrawableBuffer depthBuffer;
357
 
    __GLdrawableBuffer stencilBuffer;
358
 
#if defined(__GL_NUMBER_OF_AUX_BUFFERS) && (__GL_NUMBER_OF_AUX_BUFFERS > 0)
359
 
    __GLdrawableBuffer *auxBuffer;
360
 
#endif
361
 
 
362
 
    __GLdrawableRegion ownershipRegion;
363
 
 
364
 
    /*
365
 
    ** Lock for the drawable private structure
366
 
    */
367
 
    void *lock;
368
 
#ifdef DEBUG
369
 
    /* lock debugging info */
370
 
    int lockRefCount;
371
 
    int lockLine[10];
372
 
    char *lockFile[10];
373
 
#endif
374
 
 
375
 
    /* imported */
376
 
    void *(*malloc)(size_t size);
377
 
    void *(*calloc)(size_t numElem, size_t elemSize);
378
 
    void *(*realloc)(void *oldAddr, size_t newSize);
379
 
    void (*free)(void *addr);
380
 
 
381
 
    GLboolean (*addSwapRect)(__GLdrawablePrivate *glPriv, 
382
 
                             GLint x, GLint y, GLsizei width, GLsizei height);
383
 
    void (*setClipRect)(__GLdrawablePrivate *glPriv, 
384
 
                        GLint x, GLint y, GLsizei width, GLsizei height);
385
 
    void (*updateClipRegion)(__GLdrawablePrivate *glPriv);
386
 
    GLboolean (*resize)(__GLdrawablePrivate *glPriv);
387
 
    void (*getDrawableSize)(__GLdrawablePrivate *glPriv, 
388
 
                            GLint *x, GLint *y, GLuint *width, GLuint *height);
389
 
 
390
 
    void (*lockDP)(__GLdrawablePrivate *glPriv, __GLcontext *gc);
391
 
    void (*unlockDP)(__GLdrawablePrivate *glPriv);
392
 
 
393
 
    /* exported */
394
 
#ifdef __cplusplus
395
 
    void *privatePtr;
396
 
#else
397
 
    void *private;
398
 
#endif
399
 
    void (*freePrivate)(__GLdrawablePrivate *);
400
 
 
401
 
    /* client data */
402
 
    void *other;
403
 
};
404
 
 
405
 
/*
406
 
** Macros to lock/unlock the drawable private
407
 
*/
408
 
#if defined(DEBUG)
409
 
#define __GL_LOCK_DP(glPriv,gc) \
410
 
    (*(glPriv)->lockDP)(glPriv,gc); \
411
 
    (glPriv)->lockLine[(glPriv)->lockRefCount] = __LINE__; \
412
 
    (glPriv)->lockFile[(glPriv)->lockRefCount] = __FILE__; \
413
 
    (glPriv)->lockRefCount++
414
 
#define __GL_UNLOCK_DP(glPriv) \
415
 
    (glPriv)->lockRefCount--; \
416
 
    (glPriv)->lockLine[(glPriv)->lockRefCount] = 0; \
417
 
    (glPriv)->lockFile[(glPriv)->lockRefCount] = NULL; \
418
 
    (*(glPriv)->unlockDP)(glPriv)
419
 
#else /* DEBUG */
420
 
#define __GL_LOCK_DP(glPriv,gc)         (*(glPriv)->lockDP)(glPriv,gc)
421
 
#define __GL_UNLOCK_DP(glPriv)          (*(glPriv)->unlockDP)(glPriv)
422
 
#endif /* DEBUG */
423
 
 
424
 
 
425
 
/*
426
 
** Procedures which are imported by the GL from the surrounding
427
 
** "operating system".  Math functions are not considered part of the
428
 
** "operating system".
429
 
*/
430
 
typedef struct __GLimportsRec {
431
 
    /* Memory management */
432
 
    void * (*malloc)(__GLcontext *gc, size_t size);
433
 
    void *(*calloc)(__GLcontext *gc, size_t numElem, size_t elemSize);
434
 
    void *(*realloc)(__GLcontext *gc, void *oldAddr, size_t newSize);
435
 
    void (*free)(__GLcontext *gc, void *addr);
436
 
 
437
 
    /* Error handling */
438
 
    void (*warning)(__GLcontext *gc, char *fmt);
439
 
    void (*fatal)(__GLcontext *gc, char *fmt);
440
 
 
441
 
    /* other system calls */
442
 
    char *(CAPI *getenv)(__GLcontext *gc, const char *var);
443
 
    int (CAPI *atoi)(__GLcontext *gc, const char *str);
444
 
    int (CAPI *sprintf)(__GLcontext *gc, char *str, const char *fmt, ...);
445
 
    void *(CAPI *fopen)(__GLcontext *gc, const char *path, const char *mode);
446
 
    int (CAPI *fclose)(__GLcontext *gc, void *stream);
447
 
    int (CAPI *fprintf)(__GLcontext *gc, void *stream, const char *fmt, ...);
448
 
 
449
 
    /* Drawing surface management */
450
 
    __GLdrawablePrivate *(*getDrawablePrivate)(__GLcontext *gc);
451
 
    __GLdrawablePrivate *(*getReadablePrivate)(__GLcontext *gc);
452
 
 
453
 
    /* Operating system dependent data goes here */
454
 
    void *other;
455
 
} __GLimports;
456
 
 
457
 
/************************************************************************/
458
 
 
459
 
/*
460
 
** Procedures which are exported by the GL to the surrounding "operating
461
 
** system" so that it can manage multiple GL context's.
462
 
*/
463
 
typedef struct __GLexportsRec {
464
 
    /* Context management (return GL_FALSE on failure) */
465
 
    GLboolean (*destroyContext)(__GLcontext *gc);
466
 
    GLboolean (*loseCurrent)(__GLcontext *gc);
467
 
    /* oldglPriv isn't used anymore, kept for backwards compatibility */
468
 
    GLboolean (*makeCurrent)(__GLcontext *gc);
469
 
    GLboolean (*shareContext)(__GLcontext *gc, __GLcontext *gcShare);
470
 
    GLboolean (*copyContext)(__GLcontext *dst, const __GLcontext *src, GLuint mask);
471
 
    GLboolean (*forceCurrent)(__GLcontext *gc);
472
 
 
473
 
    /* Drawing surface notification callbacks */
474
 
    GLboolean (*notifyResize)(__GLcontext *gc);
475
 
    void (*notifyDestroy)(__GLcontext *gc);
476
 
    void (*notifySwapBuffers)(__GLcontext *gc);
477
 
 
478
 
    /* Dispatch table override control for external agents like libGLS */
479
 
    struct __GLdispatchStateRec* (*dispatchExec)(__GLcontext *gc);
480
 
    void (*beginDispatchOverride)(__GLcontext *gc);
481
 
    void (*endDispatchOverride)(__GLcontext *gc);
482
 
} __GLexports;
483
 
 
484
 
/************************************************************************/
485
 
 
486
 
/*
487
 
** This must be the first member of a __GLcontext structure.  This is the
488
 
** only part of a context that is exposed to the outside world; everything
489
 
** else is opaque.
490
 
*/
491
 
struct __GLinterfaceRec {
492
 
    __GLimports imports;
493
 
    __GLexports exports;
494
 
};
495
 
 
496
 
extern __GLcontext *__glCoreCreateContext(__GLimports *, __GLcontextModes *);
497
 
extern void __glCoreNopDispatch(void);
498
 
 
499
 
#endif /* __gl_core_h_ */