← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/glx/glxclient.h

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glx/glxclient.h
1
 
/*
2
 
 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3
 
 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
4
 
 *
5
 
 * Permission is hereby granted, free of charge, to any person obtaining a
6
 
 * copy of this software and associated documentation files (the "Software"),
7
 
 * to deal in the Software without restriction, including without limitation
8
 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9
 
 * and/or sell copies of the Software, and to permit persons to whom the
10
 
 * Software is furnished to do so, subject to the following conditions:
11
 
 *
12
 
 * The above copyright notice including the dates of first publication and
13
 
 * either this permission notice or a reference to
14
 
 * http://oss.sgi.com/projects/FreeB/
15
 
 * shall be included in all copies or substantial portions of the Software.
16
 
 *
17
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18
 
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20
 
 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21
 
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22
 
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23
 
 * SOFTWARE.
24
 
 *
25
 
 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26
 
 * shall not be used in advertising or otherwise to promote the sale, use or
27
 
 * other dealings in this Software without prior written authorization from
28
 
 * Silicon Graphics, Inc.
29
 
 */
30
 
 
31
 
/**
32
 
 * \file glxclient.h
33
 
 * Direct rendering support added by Precision Insight, Inc.
34
 
 *
35
 
 * \author Kevin E. Martin <kevin@precisioninsight.com>
36
 
 */
37
 
 
38
 
#ifndef _GLX_client_h_
39
 
#define _GLX_client_h_
40
 
#include <X11/Xproto.h>
41
 
#include <X11/Xlibint.h>
42
 
#include <X11/Xfuncproto.h>
43
 
#include <X11/extensions/extutil.h>
44
 
#define GLX_GLXEXT_PROTOTYPES
45
 
#include <GL/glx.h>
46
 
#include <GL/glxext.h>
47
 
#include <string.h>
48
 
#include <stdlib.h>
49
 
#include <stdio.h>
50
 
#include <stdint.h>
51
 
#include <pthread.h>
52
 
#include "GL/glxproto.h"
53
 
#include "glxconfig.h"
54
 
#include "glxhash.h"
55
 
#include "util/macros.h"
56
 
#include "util/u_thread.h"
57
 
#include "util/set.h"
58
 
#include "loader.h"
59
 
#include "glxextensions.h"
60
 
 
61
 
#if defined(USE_LIBGLVND)
62
 
#define _GLX_PUBLIC _X_HIDDEN
63
 
#else
64
 
#define _GLX_PUBLIC _X_EXPORT
65
 
#endif
66
 
 
67
 
#ifdef __cplusplus
68
 
extern "C" {
69
 
#endif
70
 
 
71
 
extern void glx_message(int level, const char *f, ...) PRINTFLIKE(2, 3);
72
 
 
73
 
#define DebugMessageF(...) glx_message(_LOADER_DEBUG, __VA_ARGS__)
74
 
#define InfoMessageF(...) glx_message(_LOADER_INFO, __VA_ARGS__)
75
 
#define ErrorMessageF(...) glx_message(_LOADER_WARNING, __VA_ARGS__)
76
 
#define CriticalErrorMessageF(...) glx_message(_LOADER_FATAL, __VA_ARGS__)
77
 
 
78
 
 
79
 
#define GLX_MAJOR_VERSION 1       /* current version numbers */
80
 
#define GLX_MINOR_VERSION 4
81
 
 
82
 
struct glx_display;
83
 
struct glx_context;
84
 
 
85
 
/************************************************************************/
86
 
 
87
 
#ifdef GLX_DIRECT_RENDERING
88
 
 
89
 
extern void DRI_glXUseXFont(struct glx_context *ctx,
90
 
                            Font font, int first, int count, int listbase);
91
 
 
92
 
#endif
93
 
 
94
 
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
95
 
 
96
 
/**
97
 
 * Display dependent methods.  This structure is initialized during the
98
 
 * \c driCreateDisplay call.
99
 
 */
100
 
typedef struct __GLXDRIdisplayRec __GLXDRIdisplay;
101
 
typedef struct __GLXDRIscreenRec __GLXDRIscreen;
102
 
typedef struct __GLXDRIdrawableRec __GLXDRIdrawable;
103
 
 
104
 
struct __GLXDRIdisplayRec
105
 
{
106
 
    /**
107
 
     * Method to destroy the private DRI display data.
108
 
     */
109
 
   void (*destroyDisplay) (__GLXDRIdisplay * display);
110
 
 
111
 
   struct glx_screen *(*createScreen)(int screen, struct glx_display * priv);
112
 
};
113
 
 
114
 
struct __GLXDRIscreenRec {
115
 
 
116
 
   void (*destroyScreen)(struct glx_screen *psc);
117
 
 
118
 
   __GLXDRIdrawable *(*createDrawable)(struct glx_screen *psc,
119
 
                                       XID drawable,
120
 
                                       GLXDrawable glxDrawable,
121
 
                                       int type,
122
 
                                       struct glx_config *config);
123
 
 
124
 
   int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc,
125
 
                          int64_t divisor, int64_t remainder, Bool flush);
126
 
   void (*copySubBuffer)(__GLXDRIdrawable *pdraw,
127
 
                         int x, int y, int width, int height, Bool flush);
128
 
   int (*getDrawableMSC)(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
129
 
                         int64_t *ust, int64_t *msc, int64_t *sbc);
130
 
   int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc,
131
 
                     int64_t divisor, int64_t remainder, int64_t *ust,
132
 
                     int64_t *msc, int64_t *sbc);
133
 
   int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
134
 
                     int64_t *msc, int64_t *sbc);
135
 
   int (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval);
136
 
   int (*getSwapInterval)(__GLXDRIdrawable *pdraw);
137
 
   int (*getBufferAge)(__GLXDRIdrawable *pdraw);
138
 
   void (*bindTexImage)(__GLXDRIdrawable *pdraw, int buffer, const int *attribs);
139
 
   void (*releaseTexImage)(__GLXDRIdrawable *pdraw, int buffer);
140
 
 
141
 
   int maxSwapInterval;
142
 
};
143
 
 
144
 
struct __GLXDRIdrawableRec
145
 
{
146
 
   void (*destroyDrawable) (__GLXDRIdrawable * drawable);
147
 
 
148
 
   XID xDrawable;
149
 
   XID drawable;
150
 
   struct glx_screen *psc;
151
 
   GLenum textureTarget;
152
 
   GLenum textureFormat;        /* EXT_texture_from_pixmap support */
153
 
   unsigned long eventMask;
154
 
   int refcount;
155
 
};
156
 
 
157
 
/*
158
 
** Function to create and DRI display data and initialize the display
159
 
** dependent methods.
160
 
*/
161
 
extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy, bool zink);
162
 
extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy);
163
 
extern __GLXDRIdisplay *dri3_create_display(Display * dpy);
164
 
extern __GLXDRIdisplay *driwindowsCreateDisplay(Display * dpy);
165
 
 
166
 
/*
167
 
**
168
 
*/
169
 
extern void dri2InvalidateBuffers(Display *dpy, XID drawable);
170
 
extern unsigned dri2GetSwapEventType(Display *dpy, XID drawable);
171
 
 
172
 
/*
173
 
** Functions to obtain driver configuration information from a direct
174
 
** rendering client application
175
 
*/
176
 
extern const char *glXGetScreenDriver(Display * dpy, int scrNum);
177
 
 
178
 
extern const char *glXGetDriverConfig(const char *driverName);
179
 
 
180
 
#endif
181
 
 
182
 
/************************************************************************/
183
 
 
184
 
#define __GL_CLIENT_ATTRIB_STACK_DEPTH 16
185
 
 
186
 
typedef struct __GLXpixelStoreModeRec
187
 
{
188
 
   GLboolean swapEndian;
189
 
   GLboolean lsbFirst;
190
 
   GLuint rowLength;
191
 
   GLuint imageHeight;
192
 
   GLuint imageDepth;
193
 
   GLuint skipRows;
194
 
   GLuint skipPixels;
195
 
   GLuint skipImages;
196
 
   GLuint alignment;
197
 
} __GLXpixelStoreMode;
198
 
 
199
 
 
200
 
typedef struct __GLXattributeRec
201
 
{
202
 
   GLuint mask;
203
 
 
204
 
    /**
205
 
     * Pixel storage state.  Most of the pixel store mode state is kept
206
 
     * here and used by the client code to manage the packing and
207
 
     * unpacking of data sent to/received from the server.
208
 
     */
209
 
   __GLXpixelStoreMode storePack, storeUnpack;
210
 
 
211
 
    /**
212
 
     * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically
213
 
     * disabled?
214
 
     */
215
 
   GLboolean NoDrawArraysProtocol;
216
 
 
217
 
    /**
218
 
     * Vertex Array storage state.  The vertex array component
219
 
     * state is stored here and is used to manage the packing of
220
 
     * DrawArrays data sent to the server.
221
 
     */
222
 
   struct array_state_vector *array_state;
223
 
} __GLXattribute;
224
 
 
225
 
typedef struct __GLXattributeMachineRec
226
 
{
227
 
   __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
228
 
   __GLXattribute **stackPointer;
229
 
} __GLXattributeMachine;
230
 
 
231
 
struct mesa_glinterop_device_info;
232
 
struct mesa_glinterop_export_in;
233
 
struct mesa_glinterop_export_out;
234
 
 
235
 
struct glx_context_vtable {
236
 
   void (*destroy)(struct glx_context *ctx);
237
 
   int (*bind)(struct glx_context *context, struct glx_context *old,
238
 
               GLXDrawable draw, GLXDrawable read);
239
 
   void (*unbind)(struct glx_context *context, struct glx_context *new_ctx);
240
 
   void (*wait_gl)(struct glx_context *ctx);
241
 
   void (*wait_x)(struct glx_context *ctx);
242
 
   int (*interop_query_device_info)(struct glx_context *ctx,
243
 
                                    struct mesa_glinterop_device_info *out);
244
 
   int (*interop_export_object)(struct glx_context *ctx,
245
 
                                struct mesa_glinterop_export_in *in,
246
 
                                struct mesa_glinterop_export_out *out);
247
 
};
248
 
 
249
 
/**
250
 
 * GLX state that needs to be kept on the client.  One of these records
251
 
 * exist for each context that has been made current by this client.
252
 
 */
253
 
struct glx_context
254
 
{
255
 
    /**
256
 
     * \name Drawing command buffer.
257
 
     *
258
 
     * Drawing commands are packed into this buffer before being sent as a
259
 
     * single GLX protocol request.  The buffer is sent when it overflows or
260
 
     * is flushed by \c __glXFlushRenderBuffer.  \c pc is the next location
261
 
     * in the buffer to be filled.  \c limit is described above in the buffer
262
 
     * slop discussion.
263
 
     *
264
 
     * Commands that require large amounts of data to be transfered will
265
 
     * also use this buffer to hold a header that describes the large
266
 
     * command.
267
 
     *
268
 
     * These must be the first 6 fields since they are static initialized
269
 
     * in the dummy context in glxext.c
270
 
     */
271
 
   /*@{ */
272
 
   GLubyte *buf;
273
 
   GLubyte *pc;
274
 
   GLubyte *limit;
275
 
   GLubyte *bufEnd;
276
 
   GLint bufSize;
277
 
   /*@} */
278
 
 
279
 
   const struct glx_context_vtable *vtable;
280
 
 
281
 
    /**
282
 
     * The XID of this rendering context.  When the context is created a
283
 
     * new XID is allocated.  This is set to None when the context is
284
 
     * destroyed but is still current to some thread. In this case the
285
 
     * context will be freed on next MakeCurrent.
286
 
     */
287
 
   XID xid;
288
 
 
289
 
    /**
290
 
     * The XID of the \c shareList context.
291
 
     */
292
 
   XID share_xid;
293
 
 
294
 
    /**
295
 
     * Screen number.
296
 
     */
297
 
   GLint screen;
298
 
   struct glx_screen *psc;
299
 
 
300
 
    /**
301
 
     * \c GL_TRUE if the context was created with ImportContext, which
302
 
     * means the server-side context was created by another X client.
303
 
     */
304
 
   GLboolean imported;
305
 
 
306
 
    /**
307
 
     * The context tag returned by MakeCurrent when this context is made
308
 
     * current. This tag is used to identify the context that a thread has
309
 
     * current so that proper server context management can be done.  It is
310
 
     * used for all context specific commands (i.e., \c Render, \c RenderLarge,
311
 
     * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old
312
 
     * context)).
313
 
     */
314
 
   GLXContextTag currentContextTag;
315
 
 
316
 
    /**
317
 
     * \name Rendering mode
318
 
     *
319
 
     * The rendering mode is kept on the client as well as the server.
320
 
     * When \c glRenderMode is called, the buffer associated with the
321
 
     * previous rendering mode (feedback or select) is filled.
322
 
     */
323
 
   /*@{ */
324
 
   GLenum renderMode;
325
 
   GLfloat *feedbackBuf;
326
 
   GLuint *selectBuf;
327
 
   /*@} */
328
 
 
329
 
    /**
330
 
     * Client side attribs.
331
 
     */
332
 
   __GLXattributeMachine attributes;
333
 
 
334
 
    /**
335
 
     * Client side error code.  This is set when client side gl API
336
 
     * routines need to set an error because of a bad enumerant or
337
 
     * running out of memory, etc.
338
 
     */
339
 
   GLenum error;
340
 
 
341
 
    /**
342
 
     * Whether this context does direct rendering.
343
 
     */
344
 
   Bool isDirect;
345
 
 
346
 
#if defined(GLX_DIRECT_RENDERING) && defined(GLX_USE_APPLEGL)
347
 
   void *driContext;
348
 
#endif
349
 
 
350
 
    /**
351
 
     * \c dpy of current display for this context.  Will be \c NULL if not
352
 
     * current to any display, or if this is the "dummy context".
353
 
     */
354
 
   Display *currentDpy;
355
 
 
356
 
    /**
357
 
     * The current drawable for this context.  Will be None if this
358
 
     * context is not current to any drawable.  currentReadable is below.
359
 
     */
360
 
   GLXDrawable currentDrawable;
361
 
 
362
 
    /**
363
 
     * \name GL Constant Strings
364
 
     *
365
 
     * Constant strings that describe the server implementation
366
 
     * These pertain to GL attributes, not to be confused with
367
 
     * GLX versioning attributes.
368
 
     */
369
 
   /*@{ */
370
 
   GLubyte *vendor;
371
 
   GLubyte *renderer;
372
 
   GLubyte *version;
373
 
   GLubyte *extensions;
374
 
   /*@} */
375
 
 
376
 
    /**
377
 
     * Maximum small render command size.  This is the smaller of 64k and
378
 
     * the size of the above buffer.
379
 
     */
380
 
   GLint maxSmallRenderCommandSize;
381
 
 
382
 
    /**
383
 
     * Major opcode for the extension.  Copied here so a lookup isn't
384
 
     * needed.
385
 
     */
386
 
   GLint majorOpcode;
387
 
 
388
 
    /**
389
 
     * Pointer to the config used to create this context.
390
 
     */
391
 
   struct glx_config *config;
392
 
 
393
 
    /**
394
 
     * The current read-drawable for this context.  Will be None if this
395
 
     * context is not current to any drawable.
396
 
     *
397
 
     * \since Internal API version 20030606.
398
 
     */
399
 
   GLXDrawable currentReadable;
400
 
 
401
 
   /**
402
 
    * Pointer to client-state data that is private to libGL.  This is only
403
 
    * used for indirect rendering contexts.
404
 
    *
405
 
    * No internal API version change was made for this change.  Client-side
406
 
    * drivers should NEVER use this data or even care that it exists.
407
 
    */
408
 
   void *client_state_private;
409
 
 
410
 
   /**
411
 
    * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE.
412
 
    */
413
 
   int renderType;
414
 
 
415
 
   /**
416
 
    * \name Raw server GL version
417
 
    *
418
 
    * True core GL version supported by the server.  This is the raw value
419
 
    * returned by the server, and it may not reflect what is actually
420
 
    * supported (or reported) by the client-side library.
421
 
    */
422
 
   /*@{ */
423
 
   int server_major;        /**< Major version number. */
424
 
   int server_minor;        /**< Minor version number. */
425
 
   /*@} */
426
 
 
427
 
   /**
428
 
    * Number of threads we're currently current in.
429
 
    */
430
 
   unsigned long thread_refcount;
431
 
 
432
 
   /**
433
 
    * GLX_ARB_create_context_no_error setting for this context.
434
 
    * This needs to be kept here to enforce shared context rules.
435
 
    */
436
 
   Bool noError;
437
 
 
438
 
   char gl_extension_bits[__GL_EXT_BYTES];
439
 
};
440
 
 
441
 
extern Bool
442
 
glx_context_init(struct glx_context *gc,
443
 
                 struct glx_screen *psc, struct glx_config *fbconfig);
444
 
 
445
 
#define __glXSetError(gc,code)  \
446
 
   if (!(gc)->error) {          \
447
 
      (gc)->error = code;       \
448
 
   }
449
 
 
450
 
/************************************************************************/
451
 
 
452
 
/**
453
 
 * The size of the largest drawing command known to the implementation
454
 
 * that will use the GLXRender GLX command.  In this case it is
455
 
 * \c glPolygonStipple.
456
 
 */
457
 
#define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156
458
 
 
459
 
/**
460
 
 * To keep the implementation fast, the code uses a "limit" pointer
461
 
 * to determine when the drawing command buffer is too full to hold
462
 
 * another fixed size command.  This constant defines the amount of
463
 
 * space that must always be available in the drawing command buffer
464
 
 * at all times for the implementation to work.  It is important that
465
 
 * the number be just large enough, but not so large as to reduce the
466
 
 * efficacy of the buffer.  The "+32" is just to keep the code working
467
 
 * in case somebody counts wrong.
468
 
 */
469
 
#define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32)
470
 
 
471
 
/**
472
 
 * This implementation uses a smaller threshold for switching
473
 
 * to the RenderLarge protocol than the protcol requires so that
474
 
 * large copies don't occur.
475
 
 */
476
 
#define __GLX_RENDER_CMD_SIZE_LIMIT 4096
477
 
 
478
 
/**
479
 
 * One of these records exists per screen of the display.  It contains
480
 
 * a pointer to the config data for that screen (if the screen supports GL).
481
 
 */
482
 
struct glx_screen_vtable {
483
 
   struct glx_context *(*create_context)(struct glx_screen *psc,
484
 
                                         struct glx_config *config,
485
 
                                         struct glx_context *shareList,
486
 
                                         int renderType);
487
 
 
488
 
   struct glx_context *(*create_context_attribs)(struct glx_screen *psc,
489
 
                                                 struct glx_config *config,
490
 
                                                 struct glx_context *shareList,
491
 
                                                 unsigned num_attrib,
492
 
                                                 const uint32_t *attribs,
493
 
                                                 unsigned *error);
494
 
   int (*query_renderer_integer)(struct glx_screen *psc,
495
 
                                 int attribute,
496
 
                                 unsigned int *value);
497
 
   int (*query_renderer_string)(struct glx_screen *psc,
498
 
                                int attribute,
499
 
                                const char **value);
500
 
 
501
 
   char *(*get_driver_name)(struct glx_screen *psc);
502
 
};
503
 
 
504
 
struct glx_screen
505
 
{
506
 
   const struct glx_screen_vtable *vtable;
507
 
   const struct glx_context_vtable *context_vtable;
508
 
 
509
 
    /**
510
 
     * \name Storage for the GLX vendor, version, and extension strings
511
 
     */
512
 
   /*@{ */
513
 
   const char *serverGLXexts;
514
 
   const char *serverGLXvendor;
515
 
   const char *serverGLXversion;
516
 
   /*@} */
517
 
 
518
 
    /**
519
 
     * GLX extension string to be reported to applications.  This is the
520
 
     * set of extensions that the application can actually use.
521
 
     */
522
 
   char *effectiveGLXexts;
523
 
 
524
 
   struct glx_display *display;
525
 
 
526
 
   Display *dpy;
527
 
   int scr;
528
 
   bool force_direct_context;
529
 
   bool allow_invalid_glx_destroy_window;
530
 
   bool keep_native_window_glx_drawable;
531
 
 
532
 
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
533
 
    /**
534
 
     * Per screen direct rendering interface functions and data.
535
 
     */
536
 
   __GLXDRIscreen *driScreen;
537
 
#endif
538
 
 
539
 
    /**
540
 
     * Linked list of glx visuals and  fbconfigs for this screen.
541
 
     */
542
 
   struct glx_config *visuals, *configs;
543
 
 
544
 
    /**
545
 
     * Per-screen dynamic GLX extension tracking.  The \c direct_support
546
 
     * field only contains enough bits for 64 extensions.  Should libGL
547
 
     * ever need to track more than 64 GLX extensions, we can safely grow
548
 
     * this field.  The \c struct glx_screen structure is not used outside
549
 
     * libGL.
550
 
     */
551
 
   /*@{ */
552
 
   unsigned char direct_support[__GLX_EXT_BYTES];
553
 
   GLboolean ext_list_first_time;
554
 
 
555
 
   unsigned char glx_force_enabled[__GLX_EXT_BYTES];
556
 
   unsigned char glx_force_disabled[__GLX_EXT_BYTES];
557
 
 
558
 
   unsigned char gl_force_enabled[__GL_EXT_BYTES];
559
 
   unsigned char gl_force_disabled[__GL_EXT_BYTES];
560
 
   /*@} */
561
 
 
562
 
};
563
 
 
564
 
/**
565
 
 * Per display private data.  One of these records exists for each display
566
 
 * that is using the OpenGL (GLX) extension.
567
 
 */
568
 
struct glx_display
569
 
{
570
 
   struct glx_display *next;
571
 
 
572
 
   /* The extension protocol codes */
573
 
   XExtCodes codes;
574
 
 
575
 
    /**
576
 
     * Back pointer to the display
577
 
     */
578
 
   Display *dpy;
579
 
 
580
 
    /**
581
 
     * \name Minor Version
582
 
     *
583
 
     * Minor version returned by the server during initialization. The major
584
 
     * version is asserted to be 1 during extension setup.
585
 
     */
586
 
   /*@{ */
587
 
   int minorVersion;
588
 
   /*@} */
589
 
 
590
 
    /**
591
 
     * Configurations of visuals for all screens on this display.
592
 
     * Also, per screen data which now includes the server \c GLX_EXTENSION
593
 
     * string.
594
 
     */
595
 
   struct glx_screen **screens;
596
 
 
597
 
   __glxHashTable *glXDrawHash;
598
 
 
599
 
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
600
 
   __glxHashTable *drawHash;
601
 
 
602
 
   /**
603
 
    * GLXDrawable created from native window and about to be released.
604
 
    */
605
 
   struct set *zombieGLXDrawable;
606
 
 
607
 
    /**
608
 
     * Per display direct rendering interface functions and data.
609
 
     */
610
 
   __GLXDRIdisplay *driswDisplay;
611
 
   __GLXDRIdisplay *dri2Display;
612
 
   __GLXDRIdisplay *dri3Display;
613
 
#endif
614
 
#ifdef GLX_USE_WINDOWSGL
615
 
   __GLXDRIdisplay *windowsdriDisplay;
616
 
#endif
617
 
};
618
 
 
619
 
struct glx_drawable {
620
 
   XID xDrawable;
621
 
   XID drawable;
622
 
 
623
 
   uint32_t lastEventSbc;
624
 
   int64_t eventSbcWrap;
625
 
};
626
 
 
627
 
extern int
628
 
glx_screen_init(struct glx_screen *psc,
629
 
                int screen, struct glx_display * priv);
630
 
extern void
631
 
glx_screen_cleanup(struct glx_screen *psc);
632
 
 
633
 
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
634
 
extern __GLXDRIdrawable *
635
 
dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id);
636
 
#endif
637
 
 
638
 
extern GLubyte *__glXFlushRenderBuffer(struct glx_context *, GLubyte *);
639
 
 
640
 
extern void __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber,
641
 
                                GLint totalRequests,
642
 
                                const GLvoid * data, GLint dataLen);
643
 
 
644
 
extern void __glXSendLargeCommand(struct glx_context *, const GLvoid *, GLint,
645
 
                                  const GLvoid *, GLint);
646
 
 
647
 
/* Initialize the GLX extension for dpy */
648
 
extern struct glx_display *__glXInitialize(Display *);
649
 
 
650
 
/************************************************************************/
651
 
 
652
 
extern int __glXDebug;
653
 
 
654
 
/* This is per-thread storage in an MT environment */
655
 
 
656
 
extern void __glXSetCurrentContext(struct glx_context * c);
657
 
 
658
 
# if defined( USE_ELF_TLS )
659
 
 
660
 
extern __THREAD_INITIAL_EXEC void *__glX_tls_Context;
661
 
 
662
 
#  define __glXGetCurrentContext() __glX_tls_Context
663
 
 
664
 
# else
665
 
 
666
 
extern struct glx_context *__glXGetCurrentContext(void);
667
 
 
668
 
# endif /* defined( USE_ELF_TLS ) */
669
 
 
670
 
extern void __glXSetCurrentContextNull(void);
671
 
 
672
 
 
673
 
/*
674
 
** Global lock for all threads in this address space using the GLX
675
 
** extension
676
 
*/
677
 
extern pthread_mutex_t __glXmutex;
678
 
#define __glXLock()    pthread_mutex_lock(&__glXmutex)
679
 
#define __glXUnlock()  pthread_mutex_unlock(&__glXmutex)
680
 
 
681
 
/*
682
 
** Setup for a command.  Initialize the extension for dpy if necessary.
683
 
*/
684
 
extern CARD8 __glXSetupForCommand(Display * dpy);
685
 
 
686
 
/************************************************************************/
687
 
 
688
 
/*
689
 
** Data conversion and packing support.
690
 
*/
691
 
 
692
 
extern const GLuint __glXDefaultPixelStore[9];
693
 
 
694
 
/* Send an image to the server using RenderLarge. */
695
 
extern void __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim,
696
 
                                GLint width, GLint height, GLint depth,
697
 
                                GLenum format, GLenum type,
698
 
                                const GLvoid * src, GLubyte * pc,
699
 
                                GLubyte * modes);
700
 
 
701
 
/* Return the size, in bytes, of some pixel data */
702
 
extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum);
703
 
 
704
 
/* Return the number of elements per group of a specified format*/
705
 
extern GLint __glElementsPerGroup(GLenum format, GLenum type);
706
 
 
707
 
/* Return the number of bytes per element, based on the element type (other
708
 
** than GL_BITMAP).
709
 
*/
710
 
extern GLint __glBytesPerElement(GLenum type);
711
 
 
712
 
/*
713
 
** Fill the transport buffer with the data from the users buffer,
714
 
** applying some of the pixel store modes (unpack modes) to the data
715
 
** first.  As a side effect of this call, the "modes" field is
716
 
** updated to contain the modes needed by the server to decode the
717
 
** sent data.
718
 
*/
719
 
extern void __glFillImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
720
 
                          GLenum, const GLvoid *, GLubyte *, GLubyte *);
721
 
 
722
 
/* Copy map data with a stride into a packed buffer */
723
 
extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *);
724
 
extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *);
725
 
extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint,
726
 
                          const GLfloat *, GLfloat *);
727
 
extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint,
728
 
                          const GLdouble *, GLdouble *);
729
 
 
730
 
/*
731
 
** Empty an image out of the reply buffer into the clients memory applying
732
 
** the pack modes to pack back into the clients requested format.
733
 
*/
734
 
extern void __glEmptyImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
735
 
                           GLenum, const GLubyte *, GLvoid *);
736
 
 
737
 
 
738
 
/*
739
 
** Allocate and Initialize Vertex Array client state, and free.
740
 
*/
741
 
extern void __glXInitVertexArrayState(struct glx_context *);
742
 
extern void __glXFreeVertexArrayState(struct glx_context *);
743
 
 
744
 
_X_HIDDEN void
745
 
__glX_send_client_info(struct glx_display *glx_dpy);
746
 
 
747
 
/************************************************************************/
748
 
 
749
 
extern void __glXInitializeVisualConfigFromTags(struct glx_config * config,
750
 
                                                int count, const INT32 * bp,
751
 
                                                Bool tagged_only,
752
 
                                                Bool fbconfig_style_tags);
753
 
 
754
 
extern char *__glXQueryServerString(Display *dpy, CARD32 screen, CARD32 name);
755
 
extern char *__glXGetString(Display *dpy, CARD32 screen, CARD32 name);
756
 
 
757
 
extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
758
 
                                    int32_t * numerator,
759
 
                                    int32_t * denominator);
760
 
 
761
 
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
762
 
extern GLboolean
763
 
__glxGetMscRate(struct glx_screen *psc,
764
 
                int32_t * numerator, int32_t * denominator);
765
 
 
766
 
/* So that dri2.c:DRI2WireToEvent() can access
767
 
 * glx_info->codes->first_event */
768
 
XExtDisplayInfo *__glXFindDisplay (Display *dpy);
769
 
 
770
 
extern __GLXDRIdrawable *
771
 
GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable);
772
 
#endif
773
 
 
774
 
extern struct glx_screen *GetGLXScreenConfigs(Display * dpy, int scrn);
775
 
 
776
 
#ifdef GLX_USE_APPLEGL
777
 
extern struct glx_screen *
778
 
applegl_create_screen(int screen, struct glx_display * priv);
779
 
 
780
 
extern struct glx_context *
781
 
applegl_create_context(struct glx_screen *psc,
782
 
                        struct glx_config *mode,
783
 
                        struct glx_context *shareList, int renderType);
784
 
 
785
 
extern int
786
 
applegl_create_display(struct glx_display *display);
787
 
 
788
 
extern void *
789
 
applegl_get_proc_address(const char *symbol);
790
 
#endif
791
 
 
792
 
extern Bool validate_renderType_against_config(const struct glx_config *config,
793
 
                                               int renderType);
794
 
 
795
 
 
796
 
extern struct glx_drawable *GetGLXDrawable(Display *dpy, GLXDrawable drawable);
797
 
extern int InitGLXDrawable(Display *dpy, struct glx_drawable *glxDraw,
798
 
                           XID xDrawable, GLXDrawable drawable);
799
 
extern void DestroyGLXDrawable(Display *dpy, GLXDrawable drawable);
800
 
 
801
 
extern struct glx_context dummyContext;
802
 
 
803
 
extern struct glx_screen *
804
 
indirect_create_screen(int screen, struct glx_display * priv);
805
 
extern struct glx_context *
806
 
indirect_create_context(struct glx_screen *psc,
807
 
                        struct glx_config *mode,
808
 
                        struct glx_context *shareList, int renderType);
809
 
extern struct glx_context *
810
 
indirect_create_context_attribs(struct glx_screen *base,
811
 
                                struct glx_config *config_base,
812
 
                                struct glx_context *shareList,
813
 
                                unsigned num_attribs,
814
 
                                const uint32_t *attribs,
815
 
                                unsigned *error);
816
 
 
817
 
 
818
 
extern int __glXGetDrawableAttribute(Display * dpy, GLXDrawable drawable,
819
 
                                     int attribute, unsigned int *value);
820
 
 
821
 
#ifdef __cplusplus
822
 
}
823
 
#endif
824
 
 
825
 
#endif /* !__GLX_client_h__ */