Commit | Line | Data |
---|---|---|
a09e091a JB |
1 | #ifndef _GLX_server_h_ |
2 | #define _GLX_server_h_ | |
3 | ||
4 | /* | |
5 | * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) | |
6 | * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved. | |
7 | * | |
8 | * Permission is hereby granted, free of charge, to any person obtaining a | |
9 | * copy of this software and associated documentation files (the "Software"), | |
10 | * to deal in the Software without restriction, including without limitation | |
11 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
12 | * and/or sell copies of the Software, and to permit persons to whom the | |
13 | * Software is furnished to do so, subject to the following conditions: | |
14 | * | |
15 | * The above copyright notice including the dates of first publication and | |
16 | * either this permission notice or a reference to | |
17 | * http://oss.sgi.com/projects/FreeB/ | |
18 | * shall be included in all copies or substantial portions of the Software. | |
19 | * | |
20 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
21 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
22 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
23 | * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, | |
24 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF | |
25 | * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
26 | * SOFTWARE. | |
27 | * | |
28 | * Except as contained in this notice, the name of Silicon Graphics, Inc. | |
29 | * shall not be used in advertising or otherwise to promote the sale, use or | |
30 | * other dealings in this Software without prior written authorization from | |
31 | * Silicon Graphics, Inc. | |
32 | */ | |
33 | ||
34 | #include "dmx.h" | |
35 | ||
36 | #include <misc.h> | |
37 | #include <dixstruct.h> | |
38 | #include <pixmapstr.h> | |
39 | #include <gcstruct.h> | |
40 | #include <extnsionst.h> | |
41 | #include <resource.h> | |
42 | #include <scrnintstr.h> | |
43 | ||
44 | #define GL_GLEXT_PROTOTYPES /* we want prototypes */ | |
45 | #include <GL/gl.h> | |
46 | #include <GL/glxproto.h> | |
47 | #include <GL/glxint.h> | |
48 | ||
49 | #include "glxscreens.h" | |
50 | #include "glxdrawable.h" | |
51 | #include "glxcontext.h" | |
52 | #include "glxerror.h" | |
53 | ||
54 | #define GLX_SERVER_MAJOR_VERSION 1 | |
55 | #define GLX_SERVER_MINOR_VERSION 3 | |
56 | ||
57 | #ifndef True | |
58 | #define True 1 | |
59 | #endif | |
60 | #ifndef False | |
61 | #define False 0 | |
62 | #endif | |
63 | ||
64 | /* | |
65 | ** GLX resources. | |
66 | typedef XID GLXContextID; | |
67 | typedef XID GLXPixmap; | |
68 | typedef XID GLXDrawable; | |
69 | typedef XID GLXWindow; | |
70 | typedef XID GLXPbuffer; | |
71 | ||
72 | typedef struct __GLXcontextRec *GLXContext; | |
73 | */ | |
74 | typedef struct __GLXclientStateRec __GLXclientState; | |
75 | ||
76 | extern __GLXscreenInfo *__glXActiveScreens; | |
77 | extern GLint __glXNumActiveScreens; | |
78 | ||
79 | /************************************************************************/ | |
80 | ||
81 | /* | |
82 | ** The last context used (from the server's persective) is cached. | |
83 | */ | |
84 | extern __GLXcontext *__glXLastContext; | |
85 | extern __GLXcontext *__glXForceCurrent(__GLXclientState *, GLXContextTag, | |
86 | int *); | |
87 | ||
88 | /************************************************************************/ | |
89 | ||
90 | typedef struct { | |
91 | int elem_size; /* element size in bytes */ | |
92 | int nelems; /* number of elements to swap */ | |
93 | void (*swapfunc) (GLbyte * pc); | |
94 | } __GLXRenderSwapInfo; | |
95 | ||
96 | /* | |
97 | ** State kept per client. | |
98 | */ | |
99 | struct __GLXclientStateRec { | |
100 | /* | |
101 | ** Whether this structure is currently being used to support a client. | |
102 | */ | |
103 | Bool inUse; | |
104 | ||
105 | /* | |
106 | ** Buffer for returned data. | |
107 | */ | |
108 | GLbyte *returnBuf; | |
109 | GLint returnBufSize; | |
110 | ||
111 | /* | |
112 | ** Keep a list of all the contexts that are current for this client's | |
113 | ** threads. | |
114 | */ | |
115 | __GLXcontext **currentContexts; | |
116 | DrawablePtr *currentDrawables; | |
117 | GLint numCurrentContexts; | |
118 | ||
119 | /* Back pointer to X client record */ | |
120 | ClientPtr client; | |
121 | ||
122 | char *GLClientextensions; | |
123 | ||
124 | GLXContextTag *be_currentCTag; | |
125 | Display **be_displays; | |
126 | ||
127 | /* | |
128 | ** Keep track of large rendering commands, which span multiple requests. | |
129 | */ | |
130 | GLint largeCmdBytesSoFar; /* bytes received so far */ | |
131 | GLint largeCmdBytesTotal; /* total bytes expected */ | |
132 | GLint largeCmdRequestsSoFar; /* requests received so far */ | |
133 | GLint largeCmdRequestsTotal; /* total requests expected */ | |
134 | void (*largeCmdRequestsSwapProc) (GLbyte *); | |
135 | __GLXRenderSwapInfo *largeCmdRequestsSwap_info; | |
136 | GLbyte *largeCmdBuf; | |
137 | GLint largeCmdBufSize; | |
138 | GLint largeCmdMaxReqDataSize; | |
139 | ||
140 | }; | |
141 | ||
142 | extern __GLXclientState *__glXClients[]; | |
143 | ||
144 | /************************************************************************/ | |
145 | ||
146 | /* | |
147 | ** Dispatch tables. | |
148 | */ | |
149 | typedef void (*__GLXdispatchRenderProcPtr) (GLbyte *); | |
150 | typedef int (*__GLXdispatchSingleProcPtr) (__GLXclientState *, GLbyte *); | |
151 | typedef int (*__GLXdispatchVendorPrivProcPtr) (__GLXclientState *, GLbyte *); | |
152 | extern __GLXdispatchSingleProcPtr __glXSingleTable[]; | |
153 | extern __GLXdispatchVendorPrivProcPtr __glXVendorPrivTable_EXT[]; | |
154 | extern __GLXdispatchSingleProcPtr __glXSwapSingleTable[]; | |
155 | extern __GLXdispatchVendorPrivProcPtr __glXSwapVendorPrivTable_EXT[]; | |
156 | extern __GLXdispatchRenderProcPtr __glXSwapRenderTable[]; | |
157 | ||
158 | extern __GLXRenderSwapInfo __glXSwapRenderTable_EXT[]; | |
159 | ||
160 | /* | |
161 | * Dispatch for GLX commands. | |
162 | */ | |
163 | typedef int (*__GLXprocPtr) (__GLXclientState *, char *pc); | |
164 | extern __GLXprocPtr __glXProcTable[]; | |
165 | ||
166 | /* | |
167 | * Tables for computing the size of each rendering command. | |
168 | */ | |
169 | typedef struct { | |
170 | int bytes; | |
171 | int (*varsize) (GLbyte * pc, Bool swap); | |
172 | } __GLXrenderSizeData; | |
173 | extern __GLXrenderSizeData __glXRenderSizeTable[]; | |
174 | extern __GLXrenderSizeData __glXRenderSizeTable_EXT[]; | |
175 | ||
176 | /************************************************************************/ | |
177 | ||
178 | /* | |
179 | ** X resources. | |
180 | */ | |
181 | extern RESTYPE __glXContextRes; | |
182 | extern RESTYPE __glXClientRes; | |
183 | extern RESTYPE __glXPixmapRes; | |
184 | extern RESTYPE __glXDrawableRes; | |
185 | extern RESTYPE __glXWindowRes; | |
186 | extern RESTYPE __glXPbufferRes; | |
187 | ||
188 | /************************************************************************/ | |
189 | ||
190 | /* | |
191 | ** Prototypes. | |
192 | */ | |
193 | ||
194 | extern char *__glXcombine_strings(const char *, const char *); | |
195 | ||
196 | extern void __glXDisp_DrawArrays(GLbyte *); | |
197 | extern void __glXDispSwap_DrawArrays(GLbyte *); | |
198 | ||
199 | /* | |
200 | ** Routines for sending swapped replies. | |
201 | */ | |
202 | ||
203 | extern void __glXSwapMakeCurrentReply(ClientPtr client, | |
204 | xGLXMakeCurrentReadSGIReply * reply); | |
205 | ||
206 | extern void __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply * reply); | |
207 | extern void __glXSwapQueryVersionReply(ClientPtr client, | |
208 | xGLXQueryVersionReply * reply); | |
209 | extern void __glXSwapQueryContextInfoEXTReply(ClientPtr client, | |
210 | xGLXQueryContextInfoEXTReply * | |
211 | reply, int *buf); | |
212 | extern void glxSwapQueryExtensionsStringReply(ClientPtr client, | |
213 | xGLXQueryExtensionsStringReply * | |
214 | reply, char *buf); | |
215 | extern void glxSwapQueryServerStringReply(ClientPtr client, | |
216 | xGLXQueryServerStringReply * reply, | |
217 | char *buf); | |
218 | extern void __glXSwapQueryContextReply(ClientPtr client, | |
219 | xGLXQueryContextReply * reply, int *buf); | |
220 | extern void __glXSwapGetDrawableAttributesReply(ClientPtr client, | |
221 | xGLXGetDrawableAttributesReply * | |
222 | reply, int *buf); | |
223 | extern void __glXSwapQueryMaxSwapBarriersSGIXReply(ClientPtr client, | |
224 | xGLXQueryMaxSwapBarriersSGIXReply | |
225 | * reply); | |
226 | ||
227 | /* | |
228 | * Routines for computing the size of variably-sized rendering commands. | |
229 | */ | |
230 | ||
231 | extern int __glXTypeSize(GLenum enm); | |
232 | extern int __glXImageSize(GLenum format, GLenum type, GLsizei w, GLsizei h, | |
233 | GLint rowLength, GLint skipRows, GLint alignment); | |
234 | extern int __glXImage3DSize(GLenum format, GLenum type, | |
235 | GLsizei w, GLsizei h, GLsizei d, | |
236 | GLint imageHeight, GLint rowLength, | |
237 | GLint skipImages, GLint skipRows, GLint alignment); | |
238 | ||
239 | extern int __glXCallListsReqSize(GLbyte * pc, Bool swap); | |
240 | extern int __glXBitmapReqSize(GLbyte * pc, Bool swap); | |
241 | extern int __glXFogfvReqSize(GLbyte * pc, Bool swap); | |
242 | extern int __glXFogivReqSize(GLbyte * pc, Bool swap); | |
243 | extern int __glXLightfvReqSize(GLbyte * pc, Bool swap); | |
244 | extern int __glXLightivReqSize(GLbyte * pc, Bool swap); | |
245 | extern int __glXLightModelfvReqSize(GLbyte * pc, Bool swap); | |
246 | extern int __glXLightModelivReqSize(GLbyte * pc, Bool swap); | |
247 | extern int __glXMaterialfvReqSize(GLbyte * pc, Bool swap); | |
248 | extern int __glXMaterialivReqSize(GLbyte * pc, Bool swap); | |
249 | extern int __glXTexParameterfvReqSize(GLbyte * pc, Bool swap); | |
250 | extern int __glXTexParameterivReqSize(GLbyte * pc, Bool swap); | |
251 | extern int __glXTexImage1DReqSize(GLbyte * pc, Bool swap); | |
252 | extern int __glXTexImage2DReqSize(GLbyte * pc, Bool swap); | |
253 | extern int __glXTexEnvfvReqSize(GLbyte * pc, Bool swap); | |
254 | extern int __glXTexEnvivReqSize(GLbyte * pc, Bool swap); | |
255 | extern int __glXTexGendvReqSize(GLbyte * pc, Bool swap); | |
256 | extern int __glXTexGenfvReqSize(GLbyte * pc, Bool swap); | |
257 | extern int __glXTexGenivReqSize(GLbyte * pc, Bool swap); | |
258 | extern int __glXMap1dReqSize(GLbyte * pc, Bool swap); | |
259 | extern int __glXMap1fReqSize(GLbyte * pc, Bool swap); | |
260 | extern int __glXMap2dReqSize(GLbyte * pc, Bool swap); | |
261 | extern int __glXMap2fReqSize(GLbyte * pc, Bool swap); | |
262 | extern int __glXPixelMapfvReqSize(GLbyte * pc, Bool swap); | |
263 | extern int __glXPixelMapuivReqSize(GLbyte * pc, Bool swap); | |
264 | extern int __glXPixelMapusvReqSize(GLbyte * pc, Bool swap); | |
265 | extern int __glXDrawPixelsReqSize(GLbyte * pc, Bool swap); | |
266 | extern int __glXDrawArraysSize(GLbyte * pc, Bool swap); | |
267 | extern int __glXPrioritizeTexturesReqSize(GLbyte * pc, Bool swap); | |
268 | extern int __glXTexSubImage1DReqSize(GLbyte * pc, Bool swap); | |
269 | extern int __glXTexSubImage2DReqSize(GLbyte * pc, Bool swap); | |
270 | extern int __glXTexImage3DReqSize(GLbyte * pc, Bool swap); | |
271 | extern int __glXTexSubImage3DReqSize(GLbyte * pc, Bool swap); | |
272 | extern int __glXConvolutionFilter1DReqSize(GLbyte * pc, Bool swap); | |
273 | extern int __glXConvolutionFilter2DReqSize(GLbyte * pc, Bool swap); | |
274 | extern int __glXConvolutionParameterivReqSize(GLbyte * pc, Bool swap); | |
275 | extern int __glXConvolutionParameterfvReqSize(GLbyte * pc, Bool swap); | |
276 | extern int __glXSeparableFilter2DReqSize(GLbyte * pc, Bool swap); | |
277 | extern int __glXColorTableReqSize(GLbyte * pc, Bool swap); | |
278 | extern int __glXColorSubTableReqSize(GLbyte * pc, Bool swap); | |
279 | extern int __glXColorTableParameterfvReqSize(GLbyte * pc, Bool swap); | |
280 | extern int __glXColorTableParameterivReqSize(GLbyte * pc, Bool swap); | |
281 | ||
282 | /* | |
283 | * Routines for computing the size of returned data. | |
284 | */ | |
285 | extern int __glXConvolutionParameterivSize(GLenum pname); | |
286 | extern int __glXConvolutionParameterfvSize(GLenum pname); | |
287 | extern int __glXColorTableParameterfvSize(GLenum pname); | |
288 | extern int __glXColorTableParameterivSize(GLenum pname); | |
289 | ||
290 | extern void __glXFreeGLXWindow(__glXWindow * pGlxWindow); | |
291 | extern void __glXFreeGLXPbuffer(__glXPbuffer * pGlxPbuffer); | |
292 | ||
293 | extern int __glXVersionMajor; | |
294 | extern int __glXVersionMinor; | |
295 | ||
296 | #define __GLX_IS_VERSION_SUPPORTED(major,minor) \ | |
297 | ( (__glXVersionMajor > (major)) || \ | |
298 | ((__glXVersionMajor == (major)) && (__glXVersionMinor >= (minor))) ) | |
299 | ||
300 | #endif /* !__GLX_server_h__ */ |