Commit | Line | Data |
---|---|---|
a09e091a JB |
1 | /* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */ |
2 | ||
3 | /* | |
4 | * (C) Copyright IBM Corporation 2005 | |
5 | * All Rights Reserved. | |
6 | * | |
7 | * Permission is hereby granted, free of charge, to any person obtaining a | |
8 | * copy of this software and associated documentation files (the "Software"), | |
9 | * to deal in the Software without restriction, including without limitation | |
10 | * the rights to use, copy, modify, merge, publish, distribute, sub license, | |
11 | * and/or sell copies of the Software, and to permit persons to whom the | |
12 | * Software is furnished to do so, subject to the following conditions: | |
13 | * | |
14 | * The above copyright notice and this permission notice (including the next | |
15 | * paragraph) shall be included in all copies or substantial portions of the | |
16 | * Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL | |
21 | * IBM, | |
22 | * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, | |
23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF | |
24 | * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
25 | * SOFTWARE. | |
26 | */ | |
27 | ||
28 | #include <GL/gl.h> | |
29 | #include "glxserver.h" | |
30 | #include "glxbyteorder.h" | |
31 | #include "indirect_size.h" | |
32 | #include "indirect_reqsize.h" | |
33 | ||
34 | #define __GLX_PAD(x) (((x) + 3) & ~3) | |
35 | ||
36 | #if defined(__CYGWIN__) || defined(__MINGW32__) | |
37 | #undef HAVE_ALIAS | |
38 | #endif | |
39 | #ifdef HAVE_ALIAS | |
40 | #define ALIAS2(from,to) \ | |
41 | GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \ | |
42 | __attribute__ ((alias( # to ))); | |
43 | #define ALIAS(from,to) ALIAS2( from, __glX ## to ## ReqSize ) | |
44 | #else | |
45 | #define ALIAS(from,to) \ | |
46 | GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \ | |
47 | { return __glX ## to ## ReqSize( pc, swap ); } | |
48 | #endif | |
49 | ||
50 | int | |
51 | __glXCallListsReqSize(const GLbyte * pc, Bool swap) | |
52 | { | |
53 | GLsizei n = *(GLsizei *) (pc + 0); | |
54 | GLenum type = *(GLenum *) (pc + 4); | |
55 | GLsizei compsize; | |
56 | ||
57 | if (swap) { | |
58 | n = bswap_32(n); | |
59 | type = bswap_32(type); | |
60 | } | |
61 | ||
62 | compsize = __glCallLists_size(type); | |
63 | return __GLX_PAD((compsize * n)); | |
64 | } | |
65 | ||
66 | int | |
67 | __glXBitmapReqSize(const GLbyte * pc, Bool swap) | |
68 | { | |
69 | GLint row_length = *(GLint *) (pc + 4); | |
70 | GLint image_height = 0; | |
71 | GLint skip_images = 0; | |
72 | GLint skip_rows = *(GLint *) (pc + 8); | |
73 | GLint alignment = *(GLint *) (pc + 16); | |
74 | GLsizei width = *(GLsizei *) (pc + 20); | |
75 | GLsizei height = *(GLsizei *) (pc + 24); | |
76 | ||
77 | if (swap) { | |
78 | row_length = bswap_32(row_length); | |
79 | skip_rows = bswap_32(skip_rows); | |
80 | alignment = bswap_32(alignment); | |
81 | width = bswap_32(width); | |
82 | height = bswap_32(height); | |
83 | } | |
84 | ||
85 | return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, width, height, 1, | |
86 | image_height, row_length, skip_images, | |
87 | skip_rows, alignment); | |
88 | } | |
89 | ||
90 | int | |
91 | __glXFogfvReqSize(const GLbyte * pc, Bool swap) | |
92 | { | |
93 | GLenum pname = *(GLenum *) (pc + 0); | |
94 | GLsizei compsize; | |
95 | ||
96 | if (swap) { | |
97 | pname = bswap_32(pname); | |
98 | } | |
99 | ||
100 | compsize = __glFogfv_size(pname); | |
101 | return __GLX_PAD((compsize * 4)); | |
102 | } | |
103 | ||
104 | int | |
105 | __glXLightfvReqSize(const GLbyte * pc, Bool swap) | |
106 | { | |
107 | GLenum pname = *(GLenum *) (pc + 4); | |
108 | GLsizei compsize; | |
109 | ||
110 | if (swap) { | |
111 | pname = bswap_32(pname); | |
112 | } | |
113 | ||
114 | compsize = __glLightfv_size(pname); | |
115 | return __GLX_PAD((compsize * 4)); | |
116 | } | |
117 | ||
118 | int | |
119 | __glXLightModelfvReqSize(const GLbyte * pc, Bool swap) | |
120 | { | |
121 | GLenum pname = *(GLenum *) (pc + 0); | |
122 | GLsizei compsize; | |
123 | ||
124 | if (swap) { | |
125 | pname = bswap_32(pname); | |
126 | } | |
127 | ||
128 | compsize = __glLightModelfv_size(pname); | |
129 | return __GLX_PAD((compsize * 4)); | |
130 | } | |
131 | ||
132 | int | |
133 | __glXMaterialfvReqSize(const GLbyte * pc, Bool swap) | |
134 | { | |
135 | GLenum pname = *(GLenum *) (pc + 4); | |
136 | GLsizei compsize; | |
137 | ||
138 | if (swap) { | |
139 | pname = bswap_32(pname); | |
140 | } | |
141 | ||
142 | compsize = __glMaterialfv_size(pname); | |
143 | return __GLX_PAD((compsize * 4)); | |
144 | } | |
145 | ||
146 | int | |
147 | __glXPolygonStippleReqSize(const GLbyte * pc, Bool swap) | |
148 | { | |
149 | GLint row_length = *(GLint *) (pc + 4); | |
150 | GLint image_height = 0; | |
151 | GLint skip_images = 0; | |
152 | GLint skip_rows = *(GLint *) (pc + 8); | |
153 | GLint alignment = *(GLint *) (pc + 16); | |
154 | ||
155 | if (swap) { | |
156 | row_length = bswap_32(row_length); | |
157 | skip_rows = bswap_32(skip_rows); | |
158 | alignment = bswap_32(alignment); | |
159 | } | |
160 | ||
161 | return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, 32, 32, 1, | |
162 | image_height, row_length, skip_images, | |
163 | skip_rows, alignment); | |
164 | } | |
165 | ||
166 | int | |
167 | __glXTexParameterfvReqSize(const GLbyte * pc, Bool swap) | |
168 | { | |
169 | GLenum pname = *(GLenum *) (pc + 4); | |
170 | GLsizei compsize; | |
171 | ||
172 | if (swap) { | |
173 | pname = bswap_32(pname); | |
174 | } | |
175 | ||
176 | compsize = __glTexParameterfv_size(pname); | |
177 | return __GLX_PAD((compsize * 4)); | |
178 | } | |
179 | ||
180 | int | |
181 | __glXTexImage1DReqSize(const GLbyte * pc, Bool swap) | |
182 | { | |
183 | GLint row_length = *(GLint *) (pc + 4); | |
184 | GLint image_height = 0; | |
185 | GLint skip_images = 0; | |
186 | GLint skip_rows = *(GLint *) (pc + 8); | |
187 | GLint alignment = *(GLint *) (pc + 16); | |
188 | GLenum target = *(GLenum *) (pc + 20); | |
189 | GLsizei width = *(GLsizei *) (pc + 32); | |
190 | GLenum format = *(GLenum *) (pc + 44); | |
191 | GLenum type = *(GLenum *) (pc + 48); | |
192 | ||
193 | if (swap) { | |
194 | row_length = bswap_32(row_length); | |
195 | skip_rows = bswap_32(skip_rows); | |
196 | alignment = bswap_32(alignment); | |
197 | target = bswap_32(target); | |
198 | width = bswap_32(width); | |
199 | format = bswap_32(format); | |
200 | type = bswap_32(type); | |
201 | } | |
202 | ||
203 | return __glXImageSize(format, type, target, width, 1, 1, | |
204 | image_height, row_length, skip_images, | |
205 | skip_rows, alignment); | |
206 | } | |
207 | ||
208 | int | |
209 | __glXTexImage2DReqSize(const GLbyte * pc, Bool swap) | |
210 | { | |
211 | GLint row_length = *(GLint *) (pc + 4); | |
212 | GLint image_height = 0; | |
213 | GLint skip_images = 0; | |
214 | GLint skip_rows = *(GLint *) (pc + 8); | |
215 | GLint alignment = *(GLint *) (pc + 16); | |
216 | GLenum target = *(GLenum *) (pc + 20); | |
217 | GLsizei width = *(GLsizei *) (pc + 32); | |
218 | GLsizei height = *(GLsizei *) (pc + 36); | |
219 | GLenum format = *(GLenum *) (pc + 44); | |
220 | GLenum type = *(GLenum *) (pc + 48); | |
221 | ||
222 | if (swap) { | |
223 | row_length = bswap_32(row_length); | |
224 | skip_rows = bswap_32(skip_rows); | |
225 | alignment = bswap_32(alignment); | |
226 | target = bswap_32(target); | |
227 | width = bswap_32(width); | |
228 | height = bswap_32(height); | |
229 | format = bswap_32(format); | |
230 | type = bswap_32(type); | |
231 | } | |
232 | ||
233 | return __glXImageSize(format, type, target, width, height, 1, | |
234 | image_height, row_length, skip_images, | |
235 | skip_rows, alignment); | |
236 | } | |
237 | ||
238 | int | |
239 | __glXTexEnvfvReqSize(const GLbyte * pc, Bool swap) | |
240 | { | |
241 | GLenum pname = *(GLenum *) (pc + 4); | |
242 | GLsizei compsize; | |
243 | ||
244 | if (swap) { | |
245 | pname = bswap_32(pname); | |
246 | } | |
247 | ||
248 | compsize = __glTexEnvfv_size(pname); | |
249 | return __GLX_PAD((compsize * 4)); | |
250 | } | |
251 | ||
252 | int | |
253 | __glXTexGendvReqSize(const GLbyte * pc, Bool swap) | |
254 | { | |
255 | GLenum pname = *(GLenum *) (pc + 4); | |
256 | GLsizei compsize; | |
257 | ||
258 | if (swap) { | |
259 | pname = bswap_32(pname); | |
260 | } | |
261 | ||
262 | compsize = __glTexGendv_size(pname); | |
263 | return __GLX_PAD((compsize * 8)); | |
264 | } | |
265 | ||
266 | int | |
267 | __glXTexGenfvReqSize(const GLbyte * pc, Bool swap) | |
268 | { | |
269 | GLenum pname = *(GLenum *) (pc + 4); | |
270 | GLsizei compsize; | |
271 | ||
272 | if (swap) { | |
273 | pname = bswap_32(pname); | |
274 | } | |
275 | ||
276 | compsize = __glTexGenfv_size(pname); | |
277 | return __GLX_PAD((compsize * 4)); | |
278 | } | |
279 | ||
280 | int | |
281 | __glXPixelMapfvReqSize(const GLbyte * pc, Bool swap) | |
282 | { | |
283 | GLsizei mapsize = *(GLsizei *) (pc + 4); | |
284 | ||
285 | if (swap) { | |
286 | mapsize = bswap_32(mapsize); | |
287 | } | |
288 | ||
289 | return __GLX_PAD((mapsize * 4)); | |
290 | } | |
291 | ||
292 | int | |
293 | __glXPixelMapusvReqSize(const GLbyte * pc, Bool swap) | |
294 | { | |
295 | GLsizei mapsize = *(GLsizei *) (pc + 4); | |
296 | ||
297 | if (swap) { | |
298 | mapsize = bswap_32(mapsize); | |
299 | } | |
300 | ||
301 | return __GLX_PAD((mapsize * 2)); | |
302 | } | |
303 | ||
304 | int | |
305 | __glXDrawPixelsReqSize(const GLbyte * pc, Bool swap) | |
306 | { | |
307 | GLint row_length = *(GLint *) (pc + 4); | |
308 | GLint image_height = 0; | |
309 | GLint skip_images = 0; | |
310 | GLint skip_rows = *(GLint *) (pc + 8); | |
311 | GLint alignment = *(GLint *) (pc + 16); | |
312 | GLsizei width = *(GLsizei *) (pc + 20); | |
313 | GLsizei height = *(GLsizei *) (pc + 24); | |
314 | GLenum format = *(GLenum *) (pc + 28); | |
315 | GLenum type = *(GLenum *) (pc + 32); | |
316 | ||
317 | if (swap) { | |
318 | row_length = bswap_32(row_length); | |
319 | skip_rows = bswap_32(skip_rows); | |
320 | alignment = bswap_32(alignment); | |
321 | width = bswap_32(width); | |
322 | height = bswap_32(height); | |
323 | format = bswap_32(format); | |
324 | type = bswap_32(type); | |
325 | } | |
326 | ||
327 | return __glXImageSize(format, type, 0, width, height, 1, | |
328 | image_height, row_length, skip_images, | |
329 | skip_rows, alignment); | |
330 | } | |
331 | ||
332 | int | |
333 | __glXPrioritizeTexturesReqSize(const GLbyte * pc, Bool swap) | |
334 | { | |
335 | GLsizei n = *(GLsizei *) (pc + 0); | |
336 | ||
337 | if (swap) { | |
338 | n = bswap_32(n); | |
339 | } | |
340 | ||
341 | return __GLX_PAD((n * 4) + (n * 4)); | |
342 | } | |
343 | ||
344 | int | |
345 | __glXTexSubImage1DReqSize(const GLbyte * pc, Bool swap) | |
346 | { | |
347 | GLint row_length = *(GLint *) (pc + 4); | |
348 | GLint image_height = 0; | |
349 | GLint skip_images = 0; | |
350 | GLint skip_rows = *(GLint *) (pc + 8); | |
351 | GLint alignment = *(GLint *) (pc + 16); | |
352 | GLenum target = *(GLenum *) (pc + 20); | |
353 | GLsizei width = *(GLsizei *) (pc + 36); | |
354 | GLenum format = *(GLenum *) (pc + 44); | |
355 | GLenum type = *(GLenum *) (pc + 48); | |
356 | ||
357 | if (swap) { | |
358 | row_length = bswap_32(row_length); | |
359 | skip_rows = bswap_32(skip_rows); | |
360 | alignment = bswap_32(alignment); | |
361 | target = bswap_32(target); | |
362 | width = bswap_32(width); | |
363 | format = bswap_32(format); | |
364 | type = bswap_32(type); | |
365 | } | |
366 | ||
367 | return __glXImageSize(format, type, target, width, 1, 1, | |
368 | image_height, row_length, skip_images, | |
369 | skip_rows, alignment); | |
370 | } | |
371 | ||
372 | int | |
373 | __glXTexSubImage2DReqSize(const GLbyte * pc, Bool swap) | |
374 | { | |
375 | GLint row_length = *(GLint *) (pc + 4); | |
376 | GLint image_height = 0; | |
377 | GLint skip_images = 0; | |
378 | GLint skip_rows = *(GLint *) (pc + 8); | |
379 | GLint alignment = *(GLint *) (pc + 16); | |
380 | GLenum target = *(GLenum *) (pc + 20); | |
381 | GLsizei width = *(GLsizei *) (pc + 36); | |
382 | GLsizei height = *(GLsizei *) (pc + 40); | |
383 | GLenum format = *(GLenum *) (pc + 44); | |
384 | GLenum type = *(GLenum *) (pc + 48); | |
385 | ||
386 | if (swap) { | |
387 | row_length = bswap_32(row_length); | |
388 | skip_rows = bswap_32(skip_rows); | |
389 | alignment = bswap_32(alignment); | |
390 | target = bswap_32(target); | |
391 | width = bswap_32(width); | |
392 | height = bswap_32(height); | |
393 | format = bswap_32(format); | |
394 | type = bswap_32(type); | |
395 | } | |
396 | ||
397 | return __glXImageSize(format, type, target, width, height, 1, | |
398 | image_height, row_length, skip_images, | |
399 | skip_rows, alignment); | |
400 | } | |
401 | ||
402 | int | |
403 | __glXColorTableReqSize(const GLbyte * pc, Bool swap) | |
404 | { | |
405 | GLint row_length = *(GLint *) (pc + 4); | |
406 | GLint image_height = 0; | |
407 | GLint skip_images = 0; | |
408 | GLint skip_rows = *(GLint *) (pc + 8); | |
409 | GLint alignment = *(GLint *) (pc + 16); | |
410 | GLenum target = *(GLenum *) (pc + 20); | |
411 | GLsizei width = *(GLsizei *) (pc + 28); | |
412 | GLenum format = *(GLenum *) (pc + 32); | |
413 | GLenum type = *(GLenum *) (pc + 36); | |
414 | ||
415 | if (swap) { | |
416 | row_length = bswap_32(row_length); | |
417 | skip_rows = bswap_32(skip_rows); | |
418 | alignment = bswap_32(alignment); | |
419 | target = bswap_32(target); | |
420 | width = bswap_32(width); | |
421 | format = bswap_32(format); | |
422 | type = bswap_32(type); | |
423 | } | |
424 | ||
425 | return __glXImageSize(format, type, target, width, 1, 1, | |
426 | image_height, row_length, skip_images, | |
427 | skip_rows, alignment); | |
428 | } | |
429 | ||
430 | int | |
431 | __glXColorTableParameterfvReqSize(const GLbyte * pc, Bool swap) | |
432 | { | |
433 | GLenum pname = *(GLenum *) (pc + 4); | |
434 | GLsizei compsize; | |
435 | ||
436 | if (swap) { | |
437 | pname = bswap_32(pname); | |
438 | } | |
439 | ||
440 | compsize = __glColorTableParameterfv_size(pname); | |
441 | return __GLX_PAD((compsize * 4)); | |
442 | } | |
443 | ||
444 | int | |
445 | __glXColorSubTableReqSize(const GLbyte * pc, Bool swap) | |
446 | { | |
447 | GLint row_length = *(GLint *) (pc + 4); | |
448 | GLint image_height = 0; | |
449 | GLint skip_images = 0; | |
450 | GLint skip_rows = *(GLint *) (pc + 8); | |
451 | GLint alignment = *(GLint *) (pc + 16); | |
452 | GLenum target = *(GLenum *) (pc + 20); | |
453 | GLsizei count = *(GLsizei *) (pc + 28); | |
454 | GLenum format = *(GLenum *) (pc + 32); | |
455 | GLenum type = *(GLenum *) (pc + 36); | |
456 | ||
457 | if (swap) { | |
458 | row_length = bswap_32(row_length); | |
459 | skip_rows = bswap_32(skip_rows); | |
460 | alignment = bswap_32(alignment); | |
461 | target = bswap_32(target); | |
462 | count = bswap_32(count); | |
463 | format = bswap_32(format); | |
464 | type = bswap_32(type); | |
465 | } | |
466 | ||
467 | return __glXImageSize(format, type, target, count, 1, 1, | |
468 | image_height, row_length, skip_images, | |
469 | skip_rows, alignment); | |
470 | } | |
471 | ||
472 | int | |
473 | __glXConvolutionFilter1DReqSize(const GLbyte * pc, Bool swap) | |
474 | { | |
475 | GLint row_length = *(GLint *) (pc + 4); | |
476 | GLint image_height = 0; | |
477 | GLint skip_images = 0; | |
478 | GLint skip_rows = *(GLint *) (pc + 8); | |
479 | GLint alignment = *(GLint *) (pc + 16); | |
480 | GLenum target = *(GLenum *) (pc + 20); | |
481 | GLsizei width = *(GLsizei *) (pc + 28); | |
482 | GLenum format = *(GLenum *) (pc + 36); | |
483 | GLenum type = *(GLenum *) (pc + 40); | |
484 | ||
485 | if (swap) { | |
486 | row_length = bswap_32(row_length); | |
487 | skip_rows = bswap_32(skip_rows); | |
488 | alignment = bswap_32(alignment); | |
489 | target = bswap_32(target); | |
490 | width = bswap_32(width); | |
491 | format = bswap_32(format); | |
492 | type = bswap_32(type); | |
493 | } | |
494 | ||
495 | return __glXImageSize(format, type, target, width, 1, 1, | |
496 | image_height, row_length, skip_images, | |
497 | skip_rows, alignment); | |
498 | } | |
499 | ||
500 | int | |
501 | __glXConvolutionFilter2DReqSize(const GLbyte * pc, Bool swap) | |
502 | { | |
503 | GLint row_length = *(GLint *) (pc + 4); | |
504 | GLint image_height = 0; | |
505 | GLint skip_images = 0; | |
506 | GLint skip_rows = *(GLint *) (pc + 8); | |
507 | GLint alignment = *(GLint *) (pc + 16); | |
508 | GLenum target = *(GLenum *) (pc + 20); | |
509 | GLsizei width = *(GLsizei *) (pc + 28); | |
510 | GLsizei height = *(GLsizei *) (pc + 32); | |
511 | GLenum format = *(GLenum *) (pc + 36); | |
512 | GLenum type = *(GLenum *) (pc + 40); | |
513 | ||
514 | if (swap) { | |
515 | row_length = bswap_32(row_length); | |
516 | skip_rows = bswap_32(skip_rows); | |
517 | alignment = bswap_32(alignment); | |
518 | target = bswap_32(target); | |
519 | width = bswap_32(width); | |
520 | height = bswap_32(height); | |
521 | format = bswap_32(format); | |
522 | type = bswap_32(type); | |
523 | } | |
524 | ||
525 | return __glXImageSize(format, type, target, width, height, 1, | |
526 | image_height, row_length, skip_images, | |
527 | skip_rows, alignment); | |
528 | } | |
529 | ||
530 | int | |
531 | __glXConvolutionParameterfvReqSize(const GLbyte * pc, Bool swap) | |
532 | { | |
533 | GLenum pname = *(GLenum *) (pc + 4); | |
534 | GLsizei compsize; | |
535 | ||
536 | if (swap) { | |
537 | pname = bswap_32(pname); | |
538 | } | |
539 | ||
540 | compsize = __glConvolutionParameterfv_size(pname); | |
541 | return __GLX_PAD((compsize * 4)); | |
542 | } | |
543 | ||
544 | int | |
545 | __glXTexImage3DReqSize(const GLbyte * pc, Bool swap) | |
546 | { | |
547 | GLint row_length = *(GLint *) (pc + 4); | |
548 | GLint image_height = *(GLint *) (pc + 8); | |
549 | GLint skip_rows = *(GLint *) (pc + 16); | |
550 | GLint skip_images = *(GLint *) (pc + 20); | |
551 | GLint alignment = *(GLint *) (pc + 32); | |
552 | GLenum target = *(GLenum *) (pc + 36); | |
553 | GLsizei width = *(GLsizei *) (pc + 48); | |
554 | GLsizei height = *(GLsizei *) (pc + 52); | |
555 | GLsizei depth = *(GLsizei *) (pc + 56); | |
556 | GLenum format = *(GLenum *) (pc + 68); | |
557 | GLenum type = *(GLenum *) (pc + 72); | |
558 | ||
559 | if (swap) { | |
560 | row_length = bswap_32(row_length); | |
561 | image_height = bswap_32(image_height); | |
562 | skip_rows = bswap_32(skip_rows); | |
563 | skip_images = bswap_32(skip_images); | |
564 | alignment = bswap_32(alignment); | |
565 | target = bswap_32(target); | |
566 | width = bswap_32(width); | |
567 | height = bswap_32(height); | |
568 | depth = bswap_32(depth); | |
569 | format = bswap_32(format); | |
570 | type = bswap_32(type); | |
571 | } | |
572 | ||
573 | if (*(CARD32 *) (pc + 76)) | |
574 | return 0; | |
575 | ||
576 | return __glXImageSize(format, type, target, width, height, depth, | |
577 | image_height, row_length, skip_images, | |
578 | skip_rows, alignment); | |
579 | } | |
580 | ||
581 | int | |
582 | __glXTexSubImage3DReqSize(const GLbyte * pc, Bool swap) | |
583 | { | |
584 | GLint row_length = *(GLint *) (pc + 4); | |
585 | GLint image_height = *(GLint *) (pc + 8); | |
586 | GLint skip_rows = *(GLint *) (pc + 16); | |
587 | GLint skip_images = *(GLint *) (pc + 20); | |
588 | GLint alignment = *(GLint *) (pc + 32); | |
589 | GLenum target = *(GLenum *) (pc + 36); | |
590 | GLsizei width = *(GLsizei *) (pc + 60); | |
591 | GLsizei height = *(GLsizei *) (pc + 64); | |
592 | GLsizei depth = *(GLsizei *) (pc + 68); | |
593 | GLenum format = *(GLenum *) (pc + 76); | |
594 | GLenum type = *(GLenum *) (pc + 80); | |
595 | ||
596 | if (swap) { | |
597 | row_length = bswap_32(row_length); | |
598 | image_height = bswap_32(image_height); | |
599 | skip_rows = bswap_32(skip_rows); | |
600 | skip_images = bswap_32(skip_images); | |
601 | alignment = bswap_32(alignment); | |
602 | target = bswap_32(target); | |
603 | width = bswap_32(width); | |
604 | height = bswap_32(height); | |
605 | depth = bswap_32(depth); | |
606 | format = bswap_32(format); | |
607 | type = bswap_32(type); | |
608 | } | |
609 | ||
610 | return __glXImageSize(format, type, target, width, height, depth, | |
611 | image_height, row_length, skip_images, | |
612 | skip_rows, alignment); | |
613 | } | |
614 | ||
615 | int | |
616 | __glXCompressedTexImage1DReqSize(const GLbyte * pc, Bool swap) | |
617 | { | |
618 | GLsizei imageSize = *(GLsizei *) (pc + 20); | |
619 | ||
620 | if (swap) { | |
621 | imageSize = bswap_32(imageSize); | |
622 | } | |
623 | ||
624 | return __GLX_PAD(imageSize); | |
625 | } | |
626 | ||
627 | int | |
628 | __glXCompressedTexImage2DReqSize(const GLbyte * pc, Bool swap) | |
629 | { | |
630 | GLsizei imageSize = *(GLsizei *) (pc + 24); | |
631 | ||
632 | if (swap) { | |
633 | imageSize = bswap_32(imageSize); | |
634 | } | |
635 | ||
636 | return __GLX_PAD(imageSize); | |
637 | } | |
638 | ||
639 | int | |
640 | __glXCompressedTexImage3DReqSize(const GLbyte * pc, Bool swap) | |
641 | { | |
642 | GLsizei imageSize = *(GLsizei *) (pc + 28); | |
643 | ||
644 | if (swap) { | |
645 | imageSize = bswap_32(imageSize); | |
646 | } | |
647 | ||
648 | return __GLX_PAD(imageSize); | |
649 | } | |
650 | ||
651 | int | |
652 | __glXCompressedTexSubImage3DReqSize(const GLbyte * pc, Bool swap) | |
653 | { | |
654 | GLsizei imageSize = *(GLsizei *) (pc + 36); | |
655 | ||
656 | if (swap) { | |
657 | imageSize = bswap_32(imageSize); | |
658 | } | |
659 | ||
660 | return __GLX_PAD(imageSize); | |
661 | } | |
662 | ||
663 | int | |
664 | __glXPointParameterfvReqSize(const GLbyte * pc, Bool swap) | |
665 | { | |
666 | GLenum pname = *(GLenum *) (pc + 0); | |
667 | GLsizei compsize; | |
668 | ||
669 | if (swap) { | |
670 | pname = bswap_32(pname); | |
671 | } | |
672 | ||
673 | compsize = __glPointParameterfv_size(pname); | |
674 | return __GLX_PAD((compsize * 4)); | |
675 | } | |
676 | ||
677 | int | |
678 | __glXDrawBuffersReqSize(const GLbyte * pc, Bool swap) | |
679 | { | |
680 | GLsizei n = *(GLsizei *) (pc + 0); | |
681 | ||
682 | if (swap) { | |
683 | n = bswap_32(n); | |
684 | } | |
685 | ||
686 | return __GLX_PAD((n * 4)); | |
687 | } | |
688 | ||
689 | int | |
690 | __glXProgramStringARBReqSize(const GLbyte * pc, Bool swap) | |
691 | { | |
692 | GLsizei len = *(GLsizei *) (pc + 8); | |
693 | ||
694 | if (swap) { | |
695 | len = bswap_32(len); | |
696 | } | |
697 | ||
698 | return __GLX_PAD(len); | |
699 | } | |
700 | ||
701 | int | |
702 | __glXVertexAttribs1dvNVReqSize(const GLbyte * pc, Bool swap) | |
703 | { | |
704 | GLsizei n = *(GLsizei *) (pc + 4); | |
705 | ||
706 | if (swap) { | |
707 | n = bswap_32(n); | |
708 | } | |
709 | ||
710 | return __GLX_PAD((n * 8)); | |
711 | } | |
712 | ||
713 | int | |
714 | __glXVertexAttribs2dvNVReqSize(const GLbyte * pc, Bool swap) | |
715 | { | |
716 | GLsizei n = *(GLsizei *) (pc + 4); | |
717 | ||
718 | if (swap) { | |
719 | n = bswap_32(n); | |
720 | } | |
721 | ||
722 | return __GLX_PAD((n * 16)); | |
723 | } | |
724 | ||
725 | int | |
726 | __glXVertexAttribs3dvNVReqSize(const GLbyte * pc, Bool swap) | |
727 | { | |
728 | GLsizei n = *(GLsizei *) (pc + 4); | |
729 | ||
730 | if (swap) { | |
731 | n = bswap_32(n); | |
732 | } | |
733 | ||
734 | return __GLX_PAD((n * 24)); | |
735 | } | |
736 | ||
737 | int | |
738 | __glXVertexAttribs3fvNVReqSize(const GLbyte * pc, Bool swap) | |
739 | { | |
740 | GLsizei n = *(GLsizei *) (pc + 4); | |
741 | ||
742 | if (swap) { | |
743 | n = bswap_32(n); | |
744 | } | |
745 | ||
746 | return __GLX_PAD((n * 12)); | |
747 | } | |
748 | ||
749 | int | |
750 | __glXVertexAttribs3svNVReqSize(const GLbyte * pc, Bool swap) | |
751 | { | |
752 | GLsizei n = *(GLsizei *) (pc + 4); | |
753 | ||
754 | if (swap) { | |
755 | n = bswap_32(n); | |
756 | } | |
757 | ||
758 | return __GLX_PAD((n * 6)); | |
759 | } | |
760 | ||
761 | int | |
762 | __glXVertexAttribs4dvNVReqSize(const GLbyte * pc, Bool swap) | |
763 | { | |
764 | GLsizei n = *(GLsizei *) (pc + 4); | |
765 | ||
766 | if (swap) { | |
767 | n = bswap_32(n); | |
768 | } | |
769 | ||
770 | return __GLX_PAD((n * 32)); | |
771 | } | |
772 | ||
773 | ALIAS(Fogiv, Fogfv) | |
774 | ALIAS(Lightiv, Lightfv) | |
775 | ALIAS(LightModeliv, LightModelfv) | |
776 | ALIAS(Materialiv, Materialfv) | |
777 | ALIAS(TexParameteriv, TexParameterfv) | |
778 | ALIAS(TexEnviv, TexEnvfv) | |
779 | ALIAS(TexGeniv, TexGenfv) | |
780 | ALIAS(PixelMapuiv, PixelMapfv) | |
781 | ALIAS(ColorTableParameteriv, ColorTableParameterfv) | |
782 | ALIAS(ConvolutionParameteriv, ConvolutionParameterfv) | |
783 | ALIAS(CompressedTexSubImage1D, CompressedTexImage1D) | |
784 | ALIAS(CompressedTexSubImage2D, CompressedTexImage3D) | |
785 | ALIAS(PointParameteriv, PointParameterfv) | |
786 | ALIAS(DeleteFramebuffers, DrawBuffers) | |
787 | ALIAS(DeleteRenderbuffers, DrawBuffers) | |
788 | ALIAS(VertexAttribs1fvNV, PixelMapfv) | |
789 | ALIAS(VertexAttribs1svNV, PixelMapusv) | |
790 | ALIAS(VertexAttribs2fvNV, VertexAttribs1dvNV) | |
791 | ALIAS(VertexAttribs2svNV, PixelMapfv) | |
792 | ALIAS(VertexAttribs4fvNV, VertexAttribs2dvNV) | |
793 | ALIAS(VertexAttribs4svNV, VertexAttribs1dvNV) | |
794 | ALIAS(VertexAttribs4ubvNV, PixelMapfv) |