projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
- Create another branch for networking fixes
[reactos.git] / dll / 3rdparty / mesa32 / reactos.diff
1 Index: drivers/windows/gdi/wgl.c
2 ===================================================================
3 --- drivers/windows/gdi/wgl.c (revision 7)
4 +++ drivers/windows/gdi/wgl.c (working copy)
5 @@ -703,5 +703,1297 @@
6
7 WINGDIAPI const char * GLAPIENTRY wglGetExtensionsStringARB(HDC hdc)
8 {
9 - return "WGL_ARB_extensions_string";
10 + /* WGL_ARB_render_texture */
11 + return "WGL_ARB_extensions_string WGL_"
12 + "ARB_pixel_format WGL_ARB_multi"
13 + "sample WGL_EXT_swap_control WG"
14 + "L_ARB_pbuffer WGL_ARB_render_t"
15 + "exture WGL_ARB_make_current_re"
16 + "ad WGL_EXT_extensions_string W"
17 + "GL_ARB_buffer_region ";
18 }
19 +
20 +GLAPI const char * GLAPIENTRY
21 +wglGetExtensionsStringEXT (void)
22 +{
23 + /* WGL_ARB_render_texture */
24 + return "WGL_ARB_extensions_string WGL_"
25 + "ARB_pixel_format WGL_ARB_multi"
26 + "sample WGL_EXT_swap_control WG"
27 + "L_ARB_pbuffer WGL_ARB_render_t"
28 + "exture WGL_ARB_make_current_re"
29 + "ad WGL_EXT_extensions_string W"
30 + "GL_ARB_buffer_region ";
31 +}
32 +
33 +GLAPI BOOL GLAPIENTRY
34 +wglChoosePixelFormatARB (HDC hdc,
35 + const int *piAttribIList,
36 + const FLOAT *pfAttribFList,
37 + UINT nMaxFormats,
38 + int *piFormats,
39 + UINT *nNumFormats)
40 +{
41 + SetLastError(0);
42 + return FALSE;
43 +}
44 +
45 +GLAPI BOOL GLAPIENTRY
46 +wglSwapIntervalEXT (int interval)
47 +{
48 + /*
49 + WMesaContext ctx = wglGetCurrentContext();
50 + if (ctx == NULL) {
51 + return FALSE;
52 + }
53 + if (interval < 0) {
54 + interval = 0;
55 + } else if (interval > 3) {
56 + interval = 3;
57 + }
58 + ctx->gl_ctx.swapInterval = interval;
59 + return TRUE;
60 + */
61 + return FALSE;
62 +}
63 +
64 +GLAPI int GLAPIENTRY
65 +wglGetSwapIntervalEXT (void)
66 +{
67 + /*
68 +
69 + WMesaContext ctx = wglGetCurrentContext();
70 +
71 + if (ctx == NULL) {
72 + return -1;
73 + }
74 + return (int)ctx->gl_ctx.swapInterval;
75 + */
76 + return -1;
77 +}
78 +
79 +/* WGL_ARB_pixel_format */
80 +#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
81 +#define WGL_DRAW_TO_WINDOW_ARB 0x2001
82 +#define WGL_DRAW_TO_BITMAP_ARB 0x2002
83 +#define WGL_ACCELERATION_ARB 0x2003
84 +#define WGL_NEED_PALETTE_ARB 0x2004
85 +#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
86 +#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
87 +#define WGL_SWAP_METHOD_ARB 0x2007
88 +#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
89 +#define WGL_TRANSPARENT_ARB 0x200A
90 +#define WGL_SHARE_DEPTH_ARB 0x200C
91 +#define WGL_SHARE_ACCUM_ARB 0x200E
92 +#define WGL_SUPPORT_GDI_ARB 0x200F
93 +#define WGL_SUPPORT_OPENGL_ARB 0x2010
94 +#define WGL_DOUBLE_BUFFER_ARB 0x2011
95 +#define WGL_STEREO_ARB 0x2012
96 +#define WGL_PIXEL_TYPE_ARB 0x2013
97 +#define WGL_COLOR_BITS_ARB 0x2014
98 +#define WGL_RED_BITS_ARB 0x2015
99 +#define WGL_RED_SHIFT_ARB 0x2016
100 +#define WGL_GREEN_BITS_ARB 0x2017
101 +#define WGL_GREEN_SHIFT_ARB 0x2018
102 +#define WGL_BLUE_BITS_ARB 0x2019
103 +#define WGL_BLUE_SHIFT_ARB 0x201A
104 +#define WGL_ALPHA_BITS_ARB 0x201B
105 +#define WGL_ALPHA_SHIFT_ARB 0x201C
106 +#define WGL_ACCUM_BITS_ARB 0x201D
107 +#define WGL_ACCUM_RED_BITS_ARB 0x201E
108 +#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
109 +#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
110 +#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
111 +#define WGL_DEPTH_BITS_ARB 0x2022
112 +#define WGL_STENCIL_BITS_ARB 0x2023
113 +#define WGL_AUX_BUFFERS_ARB 0x2024
114 +#define WGL_NO_ACCELERATION_ARB 0x2025
115 +#define WGL_GENERIC_ACCELERATION_ARB 0x2026
116 +#define WGL_FULL_ACCELERATION_ARB 0x2027
117 +#define WGL_DRAW_TO_PBUFFER_ARB 0x202D
118 +#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
119 +#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
120 +#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
121 +#define WGL_SAMPLE_BUFFERS_ARB 0x2041
122 +#define WGL_SAMPLES_ARB 0x2042
123 +
124 +
125 +GLAPI BOOL GLAPIENTRY
126 +wglGetPixelFormatAttribivARB (HDC hdc,
127 + int iPixelFormat,
128 + int iLayerPlane,
129 + UINT nAttributes,
130 + int *piAttributes,
131 + int *piValues)
132 +{
133 + BOOL retVal = FALSE;
134 + BOOL Count = 0;
135 + int i;
136 +
137 + for (i=0;i<nAttributes;i++)
138 + {
139 + switch (piAttributes[i])
140 + {
141 +
142 + case WGL_ACCELERATION_ARB :
143 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
144 + {
145 + if ( ( pfd[iPixelFormat - 1].pfd.dwFlags & PFD_GENERIC_FORMAT ) == PFD_GENERIC_FORMAT)
146 + {
147 + piValues[i] = WGL_NO_ACCELERATION_ARB; // or WGL_GENERIC_ACCELERATION_ARB ?
148 + }
149 +
150 + else if ( ( pfd[iPixelFormat - 1].pfd.dwFlags & PFD_GENERIC_FORMAT ) == PFD_GENERIC_ACCELERATED)
151 + {
152 + piValues[i] = WGL_GENERIC_ACCELERATION_ARB; // or WGL_FULL_ACCELERATION_ARB ?
153 + }
154 + else
155 + {
156 + piValues[i] = WGL_FULL_ACCELERATION_ARB; // or WGL_NO_ACCELERATION_ARB ?
157 + }
158 + Count++;
159 + }
160 + else
161 + {
162 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
163 + }
164 +
165 + /* note from http://developer.3dlabs.com/documents/WGLmanpages/wglgetpixelformatattribarb.htm
166 + *
167 + * WGL_NO_ACCELERATION_ARB
168 + * Only the software renderer supports this pixel format.
169 + *
170 + * WGL_GENERIC_ACCELERATION_ARB
171 + * The pixel format is supported by an MCD driver.
172 + *
173 + * WGL_FULL_ACCELERATION_ARB
174 + * The pixel format is supported by an ICD driver.
175 + */
176 + break;
177 +
178 + case WGL_ACCUM_BITS_ARB :
179 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
180 + {
181 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumBits;
182 + Count++;
183 + }
184 + else
185 + {
186 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
187 + }
188 + break;
189 +
190 + case WGL_ACCUM_ALPHA_BITS_ARB :
191 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
192 + {
193 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumAlphaBits;
194 + Count++;
195 + }
196 + else
197 + {
198 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
199 + }
200 + break;
201 +
202 +
203 + case WGL_ACCUM_BLUE_BITS_ARB :
204 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
205 + {
206 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumBlueBits;
207 + Count++;
208 + }
209 + else
210 + {
211 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
212 + }
213 + break;
214 +
215 + case WGL_ACCUM_GREEN_BITS_ARB :
216 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
217 + {
218 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumGreenBits;
219 + Count++;
220 + }
221 + else
222 + {
223 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
224 + }
225 + break;
226 +
227 + case WGL_ACCUM_RED_BITS_ARB :
228 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
229 + {
230 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumRedBits;
231 + Count++;
232 + }
233 + else
234 + {
235 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
236 + }
237 + break;
238 +
239 + case WGL_ALPHA_BITS_ARB :
240 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
241 + {
242 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAlphaBits;
243 + Count++;
244 + }
245 + else
246 + {
247 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
248 + }
249 + break;
250 +
251 + case WGL_ALPHA_SHIFT_ARB :
252 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
253 + {
254 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAlphaShift;
255 + Count++;
256 + }
257 + else
258 + {
259 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
260 + }
261 + break;
262 +
263 + case WGL_AUX_BUFFERS_ARB :
264 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
265 + {
266 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAuxBuffers;
267 + Count++;
268 + }
269 + else
270 + {
271 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
272 + }
273 + break;
274 +
275 + case WGL_BLUE_BITS_ARB :
276 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
277 + {
278 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cBlueBits;
279 + Count++;
280 + }
281 + else
282 + {
283 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
284 + }
285 + break;
286 +
287 + case WGL_BLUE_SHIFT_ARB :
288 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
289 + {
290 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cBlueShift;
291 + Count++;
292 + }
293 + else
294 + {
295 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
296 + }
297 + break;
298 +
299 + case WGL_COLOR_BITS_ARB :
300 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
301 + {
302 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cColorBits;
303 + Count++;
304 + }
305 + else
306 + {
307 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
308 + }
309 + break;
310 +
311 + case WGL_DEPTH_BITS_ARB :
312 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
313 + {
314 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cDepthBits;
315 + Count++;
316 + }
317 + else
318 + {
319 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
320 + }
321 +
322 + break;
323 +
324 + case WGL_DRAW_TO_BITMAP_ARB :
325 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
326 + {
327 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.dwFlags & ~PFD_DRAW_TO_BITMAP;
328 + Count++;
329 + }
330 + else
331 + {
332 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
333 + }
334 + break;
335 +
336 + case WGL_DRAW_TO_WINDOW_ARB :
337 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
338 + {
339 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.dwFlags & ~PFD_DRAW_TO_WINDOW;
340 + Count++;
341 + }
342 + else
343 + {
344 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
345 + }
346 +
347 + break;
348 +
349 + case WGL_DRAW_TO_PBUFFER_ARB :
350 + piValues[i] = GL_TRUE;
351 + break;
352 +
353 + case WGL_DOUBLE_BUFFER_ARB :
354 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
355 + {
356 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_DOUBLEBUFFER) == PFD_DOUBLEBUFFER)
357 + {
358 + piValues[i] = GL_TRUE;
359 + }
360 + else
361 + {
362 + piValues[i] = GL_FALSE;
363 + }
364 + Count++;
365 + }
366 + else
367 + {
368 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
369 + }
370 + break;
371 +
372 + case WGL_GREEN_BITS_ARB :
373 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
374 + {
375 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cGreenBits;
376 + Count++;
377 + }
378 + else
379 + {
380 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
381 + }
382 + break;
383 +
384 + case WGL_GREEN_SHIFT_ARB :
385 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
386 + {
387 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cGreenShift;
388 + Count++;
389 + }
390 + else
391 + {
392 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
393 + }
394 + break;
395 +
396 +
397 + case WGL_MAX_PBUFFER_PIXELS_ARB :
398 + // FIXME
399 + break;
400 +
401 + case WGL_MAX_PBUFFER_WIDTH_ARB :
402 + // FIXME
403 + break;
404 +
405 + case WGL_MAX_PBUFFER_HEIGHT_ARB :
406 + // FIXME
407 + break;
408 +
409 + case WGL_NEED_PALETTE_ARB :
410 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
411 + {
412 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_NEED_PALETTE) == PFD_NEED_PALETTE)
413 + {
414 + piValues[i] = GL_TRUE;
415 + }
416 + else
417 + {
418 + piValues[i] = GL_FALSE;
419 + }
420 + Count++;
421 + }
422 + else
423 + {
424 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
425 + }
426 + break;
427 +
428 + case WGL_NEED_SYSTEM_PALETTE_ARB :
429 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
430 + {
431 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_NEED_PALETTE) == PFD_NEED_SYSTEM_PALETTE)
432 + {
433 + piValues[i] = GL_TRUE;
434 + }
435 + else
436 + {
437 + piValues[i] = GL_FALSE;
438 + }
439 + Count++;
440 + }
441 + else
442 + {
443 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
444 + }
445 + break;
446 +
447 + case WGL_NUMBER_PIXEL_FORMATS_ARB :
448 + piValues[i] = (int)npfd;
449 + Count++;
450 + break;
451 +
452 + case WGL_NUMBER_UNDERLAYS_ARB :
453 + // FIXME
454 + break;
455 +/*
456 + case WGL_OPTIMAL_PBUFFER_WIDTH_ARB
457 + // FIXME
458 + break;
459 +
460 + case WGL_OPTIMAL_PBUFFER_HEIGHT_ARB
461 + // FIXME
462 + break;
463 +*/
464 + case WGL_PIXEL_TYPE_ARB :
465 + // FIXME
466 + break;
467 +
468 + case WGL_RED_BITS_ARB :
469 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
470 + {
471 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cRedBits;
472 + Count++;
473 + }
474 + else
475 + {
476 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
477 + }
478 +
479 + break;
480 +
481 + case WGL_RED_SHIFT_ARB :
482 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
483 + {
484 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cRedShift;
485 + Count++;
486 + }
487 + else
488 + {
489 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
490 + }
491 +
492 + break;
493 +
494 + case WGL_SAMPLES_ARB :
495 + // FIXME
496 + break;
497 +
498 + case WGL_SAMPLE_BUFFERS_ARB :
499 + // FIXME
500 + break;
501 +
502 + case WGL_SHARE_ACCUM_ARB :
503 + // FIXME - True if the layer plane shares the accumulation buffer with the main planes. If iLayerPlane is zero, this is always true.
504 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
505 + {
506 + if (iLayerPlane == 0)
507 + {
508 + piValues[i] = GL_TRUE;
509 + }
510 + Count++;
511 + }
512 + else
513 + {
514 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
515 + }
516 + break;
517 +
518 + case WGL_SHARE_DEPTH_ARB :
519 + // FIXME - True if the layer plane shares the depth buffer with the main planes. If iLayerPlane is zero, this is always true.
520 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
521 + {
522 + if (iLayerPlane == 0)
523 + {
524 + piValues[i] = GL_TRUE;
525 + }
526 + Count++;
527 + }
528 + else
529 + {
530 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
531 + }
532 + break;
533 + break;
534 +
535 + case WGL_STENCIL_BITS_ARB :
536 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
537 + {
538 + piValues[i] = (int)pfd[iPixelFormat - 1].pfd.cStencilBits ;
539 + Count++;
540 + }
541 + else
542 + {
543 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
544 + }
545 + break;
546 +
547 + case WGL_STEREO_ARB :
548 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
549 + {
550 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_STEREO) == PFD_STEREO)
551 + {
552 + piValues[i] = GL_TRUE;
553 + }
554 + else
555 + {
556 + piValues[i] = GL_FALSE;
557 + }
558 + Count++;
559 + }
560 + else
561 + {
562 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
563 + }
564 + break;
565 +
566 + case WGL_SUPPORT_GDI_ARB :
567 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
568 + {
569 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_SUPPORT_GDI) == PFD_SUPPORT_GDI)
570 + {
571 + piValues[i] = GL_TRUE;
572 + }
573 + else
574 + {
575 + piValues[i] = GL_FALSE;
576 + }
577 + Count++;
578 + }
579 + else
580 + {
581 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
582 + }
583 + break;
584 +
585 + case WGL_SUPPORT_OPENGL_ARB :
586 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
587 + {
588 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_SUPPORT_OPENGL) == PFD_SUPPORT_OPENGL)
589 + {
590 + piValues[i] = GL_TRUE;
591 + }
592 + else
593 + {
594 + piValues[i] = GL_FALSE;
595 + }
596 + Count++;
597 + }
598 + else
599 + {
600 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
601 + }
602 + break;
603 +
604 + case WGL_SWAP_LAYER_BUFFERS_ARB :
605 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
606 + {
607 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_SUPPORT_OPENGL) == PFD_SWAP_LAYER_BUFFERS)
608 + {
609 + piValues[i] = GL_TRUE;
610 + }
611 + else
612 + {
613 + piValues[i] = GL_FALSE;
614 + }
615 + Count++;
616 + }
617 + else
618 + {
619 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
620 + }
621 + break;
622 +
623 + case WGL_SWAP_METHOD_ARB :
624 + // FIXME
625 + break;
626 +
627 + case WGL_TRANSPARENT_ARB :
628 + //FIXME after WGL_TRANSPARENT_VALUE been implement piValues[i] = GL_TRUE;
629 + piValues[i] = GL_FALSE;
630 + Count++;
631 + break;
632 +
633 + default :
634 + SetLastError(0);
635 + break;
636 + }
637 + }
638 +
639 + if(GetObjectType(hdc) != OBJ_DC)
640 + {
641 + SetLastError(ERROR_DC_NOT_FOUND);
642 + }
643 + else if (Count == nAttributes)
644 + {
645 + retVal = TRUE;
646 + }
647 +
648 +
649 + return retVal;
650 +}
651 +
652 +GLAPI BOOL GLAPIENTRY
653 +wglGetPixelFormatAttribfvARB (HDC hdc,
654 + int iPixelFormat,
655 + int iLayerPlane,
656 + UINT nAttributes,
657 + int *piAttributes,
658 + FLOAT *pfValues)
659 +{
660 + BOOL retVal = FALSE;
661 + BOOL Count = 0;
662 + int i;
663 +
664 + for (i=0;i<nAttributes;i++)
665 + {
666 + switch (piAttributes[i])
667 + {
668 +
669 + case WGL_ACCELERATION_ARB :
670 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
671 + {
672 + if ( ( pfd[iPixelFormat - 1].pfd.dwFlags & PFD_GENERIC_FORMAT ) == PFD_GENERIC_FORMAT)
673 + {
674 + pfValues[i] = WGL_NO_ACCELERATION_ARB; // or WGL_GENERIC_ACCELERATION_ARB ?
675 + }
676 +
677 + else if ( ( pfd[iPixelFormat - 1].pfd.dwFlags & PFD_GENERIC_FORMAT ) == PFD_GENERIC_ACCELERATED)
678 + {
679 + pfValues[i] = WGL_GENERIC_ACCELERATION_ARB; // or WGL_FULL_ACCELERATION_ARB ?
680 + }
681 + else
682 + {
683 + pfValues[i] = WGL_FULL_ACCELERATION_ARB; // or WGL_NO_ACCELERATION_ARB ?
684 + }
685 + Count++;
686 + }
687 + else
688 + {
689 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
690 + }
691 +
692 + /* note from http://developer.3dlabs.com/documents/WGLmanpages/wglgetpixelformatattribarb.htm
693 + *
694 + * WGL_NO_ACCELERATION_ARB
695 + * Only the software renderer supports this pixel format.
696 + *
697 + * WGL_GENERIC_ACCELERATION_ARB
698 + * The pixel format is supported by an MCD driver.
699 + *
700 + * WGL_FULL_ACCELERATION_ARB
701 + * The pixel format is supported by an ICD driver.
702 + */
703 + break;
704 +
705 + case WGL_ACCUM_BITS_ARB :
706 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
707 + {
708 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumBits;
709 + Count++;
710 + }
711 + else
712 + {
713 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
714 + }
715 + break;
716 +
717 + case WGL_ACCUM_ALPHA_BITS_ARB :
718 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
719 + {
720 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumAlphaBits;
721 + Count++;
722 + }
723 + else
724 + {
725 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
726 + }
727 + break;
728 +
729 +
730 + case WGL_ACCUM_BLUE_BITS_ARB :
731 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
732 + {
733 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumBlueBits;
734 + Count++;
735 + }
736 + else
737 + {
738 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
739 + }
740 + break;
741 +
742 + case WGL_ACCUM_GREEN_BITS_ARB :
743 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
744 + {
745 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumGreenBits;
746 + Count++;
747 + }
748 + else
749 + {
750 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
751 + }
752 + break;
753 +
754 + case WGL_ACCUM_RED_BITS_ARB :
755 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
756 + {
757 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAccumRedBits;
758 + Count++;
759 + }
760 + else
761 + {
762 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
763 + }
764 + break;
765 +
766 + case WGL_ALPHA_BITS_ARB :
767 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
768 + {
769 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAlphaBits;
770 + Count++;
771 + }
772 + else
773 + {
774 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
775 + }
776 + break;
777 +
778 + case WGL_ALPHA_SHIFT_ARB :
779 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
780 + {
781 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAlphaShift;
782 + Count++;
783 + }
784 + else
785 + {
786 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
787 + }
788 + break;
789 +
790 + case WGL_AUX_BUFFERS_ARB :
791 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
792 + {
793 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cAuxBuffers;
794 + Count++;
795 + }
796 + else
797 + {
798 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
799 + }
800 + break;
801 +
802 + case WGL_BLUE_BITS_ARB :
803 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
804 + {
805 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cBlueBits;
806 + Count++;
807 + }
808 + else
809 + {
810 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
811 + }
812 + break;
813 +
814 + case WGL_BLUE_SHIFT_ARB :
815 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
816 + {
817 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cBlueShift;
818 + Count++;
819 + }
820 + else
821 + {
822 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
823 + }
824 + break;
825 +
826 + case WGL_COLOR_BITS_ARB :
827 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
828 + {
829 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cColorBits;
830 + Count++;
831 + }
832 + else
833 + {
834 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
835 + }
836 + break;
837 +
838 + case WGL_DEPTH_BITS_ARB :
839 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
840 + {
841 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cDepthBits;
842 + Count++;
843 + }
844 + else
845 + {
846 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
847 + }
848 +
849 + break;
850 +
851 + case WGL_DRAW_TO_BITMAP_ARB :
852 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
853 + {
854 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.dwFlags & ~PFD_DRAW_TO_BITMAP;
855 + Count++;
856 + }
857 + else
858 + {
859 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
860 + }
861 + break;
862 +
863 + case WGL_DRAW_TO_WINDOW_ARB :
864 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
865 + {
866 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.dwFlags & ~PFD_DRAW_TO_WINDOW;
867 + Count++;
868 + }
869 + else
870 + {
871 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
872 + }
873 +
874 + break;
875 +
876 + case WGL_DRAW_TO_PBUFFER_ARB :
877 + pfValues[i] = GL_TRUE;
878 + break;
879 +
880 + case WGL_DOUBLE_BUFFER_ARB :
881 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
882 + {
883 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_DOUBLEBUFFER) == PFD_DOUBLEBUFFER)
884 + {
885 + pfValues[i] = GL_TRUE;
886 + }
887 + else
888 + {
889 + pfValues[i] = GL_FALSE;
890 + }
891 + Count++;
892 + }
893 + else
894 + {
895 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
896 + }
897 + break;
898 +
899 + case WGL_GREEN_BITS_ARB :
900 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
901 + {
902 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cGreenBits;
903 + Count++;
904 + }
905 + else
906 + {
907 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
908 + }
909 + break;
910 +
911 + case WGL_GREEN_SHIFT_ARB :
912 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
913 + {
914 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cGreenShift;
915 + Count++;
916 + }
917 + else
918 + {
919 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
920 + }
921 + break;
922 +
923 +
924 + case WGL_MAX_PBUFFER_PIXELS_ARB :
925 + // FIXME
926 + break;
927 +
928 + case WGL_MAX_PBUFFER_WIDTH_ARB :
929 + // FIXME
930 + break;
931 +
932 + case WGL_MAX_PBUFFER_HEIGHT_ARB :
933 + // FIXME
934 + break;
935 +
936 + case WGL_NEED_PALETTE_ARB :
937 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
938 + {
939 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_NEED_PALETTE) == PFD_NEED_PALETTE)
940 + {
941 + pfValues[i] = GL_TRUE;
942 + }
943 + else
944 + {
945 + pfValues[i] = GL_FALSE;
946 + }
947 + Count++;
948 + }
949 + else
950 + {
951 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
952 + }
953 + break;
954 +
955 + case WGL_NEED_SYSTEM_PALETTE_ARB :
956 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
957 + {
958 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_NEED_PALETTE) == PFD_NEED_SYSTEM_PALETTE)
959 + {
960 + pfValues[i] = GL_TRUE;
961 + }
962 + else
963 + {
964 + pfValues[i] = GL_FALSE;
965 + }
966 + Count++;
967 + }
968 + else
969 + {
970 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
971 + }
972 + break;
973 +
974 + case WGL_NUMBER_PIXEL_FORMATS_ARB :
975 + pfValues[i] = (int)npfd;
976 + Count++;
977 + break;
978 +
979 + case WGL_NUMBER_UNDERLAYS_ARB :
980 + // FIXME
981 + break;
982 +/*
983 + case WGL_OPTIMAL_PBUFFER_WIDTH_ARB
984 + // FIXME
985 + break;
986 +
987 + case WGL_OPTIMAL_PBUFFER_HEIGHT_ARB
988 + // FIXME
989 + break;
990 +*/
991 + case WGL_PIXEL_TYPE_ARB :
992 + // FIXME
993 + break;
994 +
995 + case WGL_RED_BITS_ARB :
996 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
997 + {
998 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cRedBits;
999 + Count++;
1000 + }
1001 + else
1002 + {
1003 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1004 + }
1005 +
1006 + break;
1007 +
1008 + case WGL_RED_SHIFT_ARB :
1009 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1010 + {
1011 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cRedShift;
1012 + Count++;
1013 + }
1014 + else
1015 + {
1016 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1017 + }
1018 +
1019 + break;
1020 +
1021 + case WGL_SAMPLES_ARB :
1022 + // FIXME
1023 + break;
1024 +
1025 + case WGL_SAMPLE_BUFFERS_ARB :
1026 + // FIXME
1027 + break;
1028 +
1029 + case WGL_SHARE_ACCUM_ARB :
1030 + // FIXME - True if the layer plane shares the accumulation buffer with the main planes. If iLayerPlane is zero, this is always true.
1031 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1032 + {
1033 + if (iLayerPlane == 0)
1034 + {
1035 + pfValues[i] = GL_TRUE;
1036 + }
1037 + Count++;
1038 + }
1039 + else
1040 + {
1041 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1042 + }
1043 + break;
1044 +
1045 + case WGL_SHARE_DEPTH_ARB :
1046 + // FIXME - True if the layer plane shares the depth buffer with the main planes. If iLayerPlane is zero, this is always true.
1047 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1048 + {
1049 + if (iLayerPlane == 0)
1050 + {
1051 + pfValues[i] = GL_TRUE;
1052 + }
1053 + Count++;
1054 + }
1055 + else
1056 + {
1057 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1058 + }
1059 + break;
1060 +
1061 + case WGL_STENCIL_BITS_ARB :
1062 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1063 + {
1064 + pfValues[i] = (int)pfd[iPixelFormat - 1].pfd.cStencilBits ;
1065 + Count++;
1066 + }
1067 + else
1068 + {
1069 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1070 + }
1071 + break;
1072 +
1073 + case WGL_STEREO_ARB :
1074 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1075 + {
1076 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_STEREO) == PFD_STEREO)
1077 + {
1078 + pfValues[i] = GL_TRUE;
1079 + }
1080 + else
1081 + {
1082 + pfValues[i] = GL_FALSE;
1083 + }
1084 + Count++;
1085 + }
1086 + else
1087 + {
1088 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1089 + }
1090 + break;
1091 +
1092 + case WGL_SUPPORT_GDI_ARB :
1093 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1094 + {
1095 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_SUPPORT_GDI) == PFD_SUPPORT_GDI)
1096 + {
1097 + pfValues[i] = GL_TRUE;
1098 + }
1099 + else
1100 + {
1101 + pfValues[i] = GL_FALSE;
1102 + }
1103 + Count++;
1104 + }
1105 + else
1106 + {
1107 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1108 + }
1109 + break;
1110 +
1111 + case WGL_SUPPORT_OPENGL_ARB :
1112 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1113 + {
1114 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_SUPPORT_OPENGL) == PFD_SUPPORT_OPENGL)
1115 + {
1116 + pfValues[i] = GL_TRUE;
1117 + }
1118 + else
1119 + {
1120 + pfValues[i] = GL_FALSE;
1121 + }
1122 + Count++;
1123 + }
1124 + else
1125 + {
1126 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1127 + }
1128 + break;
1129 +
1130 + case WGL_SWAP_LAYER_BUFFERS_ARB :
1131 + if ((iPixelFormat > 0) && (iPixelFormat<=npfd))
1132 + {
1133 + if ((pfd[iPixelFormat - 1].pfd.dwFlags & PFD_SUPPORT_OPENGL) == PFD_SWAP_LAYER_BUFFERS)
1134 + {
1135 + pfValues[i] = GL_TRUE;
1136 + }
1137 + else
1138 + {
1139 + pfValues[i] = GL_FALSE;
1140 + }
1141 + Count++;
1142 + }
1143 + else
1144 + {
1145 + SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1146 + }
1147 + break;
1148 +
1149 + case WGL_SWAP_METHOD_ARB :
1150 + // FIXME
1151 + break;
1152 +
1153 + case WGL_TRANSPARENT_ARB :
1154 + //FIXME after WGL_TRANSPARENT_VALUE been implement piValues[i] = GL_TRUE;
1155 + pfValues[i] = GL_FALSE;
1156 + Count++;
1157 + break;
1158 +
1159 + default :
1160 + SetLastError(0);
1161 + break;
1162 + }
1163 + }
1164 +
1165 + if(GetObjectType(hdc) != OBJ_DC)
1166 + {
1167 + SetLastError(ERROR_DC_NOT_FOUND);
1168 + }
1169 + else if (Count == nAttributes)
1170 + {
1171 + retVal = TRUE;
1172 + }
1173 +
1174 + return retVal;
1175 +}
1176 +
1177 +
1178 +GLAPI BOOL GLAPIENTRY
1179 +wglMakeContextCurrentARB(HDC hDrawDC,
1180 + HDC hReadDC,
1181 + HGLRC hglrc)
1182 +{
1183 + SetLastError(0);
1184 + return FALSE;
1185 +}
1186 +
1187 +GLAPI HANDLE GLAPIENTRY
1188 +wglGetCurrentReadDCARB(void)
1189 +{
1190 + SetLastError(0);
1191 + return NULL;
1192 +}
1193 +
1194 +typedef void *HPBUFFERARB;
1195 +
1196 +/* WGL_ARB_pbuffer */
1197 +GLAPI HPBUFFERARB GLAPIENTRY
1198 +wglCreatePbufferARB (HDC hDC,
1199 + int iPixelFormat,
1200 + int iWidth,
1201 + int iHeight,
1202 + const int *piAttribList)
1203 +{
1204 + SetLastError(0);
1205 + return NULL;
1206 +}
1207 +
1208 +GLAPI HDC GLAPIENTRY
1209 +wglGetPbufferDCARB (HPBUFFERARB hPbuffer)
1210 +{
1211 + SetLastError(0);
1212 + return NULL;
1213 +}
1214 +
1215 +GLAPI int GLAPIENTRY
1216 +wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC)
1217 +{
1218 + SetLastError(0);
1219 + return -1;
1220 +}
1221 +
1222 +GLAPI BOOL GLAPIENTRY
1223 +wglDestroyPbufferARB (HPBUFFERARB hPbuffer)
1224 +{
1225 + SetLastError(0);
1226 + return FALSE;
1227 +}
1228 +
1229 +GLAPI BOOL GLAPIENTRY
1230 +wglQueryPbufferARB (HPBUFFERARB hPbuffer,
1231 + int iAttribute,
1232 + int *piValue)
1233 +{
1234 + SetLastError(0);
1235 + return FALSE;
1236 +}
1237 +
1238 +GLAPI HANDLE GLAPIENTRY
1239 +wglCreateBufferRegionARB(HDC hDC,
1240 + int iLayerPlane,
1241 + UINT uType)
1242 +{
1243 + SetLastError(0);
1244 + return NULL;
1245 +}
1246 +
1247 +GLAPI VOID GLAPIENTRY
1248 +wglDeleteBufferRegionARB(HANDLE hRegion)
1249 +{
1250 + SetLastError(0);
1251 + return;
1252 +}
1253 +
1254 +GLAPI BOOL GLAPIENTRY
1255 +wglSaveBufferRegionARB(HANDLE hRegion,
1256 + int x,
1257 + int y,
1258 + int width,
1259 + int height)
1260 +{
1261 + SetLastError(0);
1262 + return FALSE;
1263 +}
1264 +
1265 +GLAPI BOOL GLAPIENTRY
1266 +wglRestoreBufferRegionARB(HANDLE hRegion,
1267 + int x,
1268 + int y,
1269 + int width,
1270 + int height,
1271 + int xSrc,
1272 + int ySrc)
1273 +{
1274 + SetLastError(0);
1275 + return FALSE;
1276 +}
1277 +
1278 +/* WGL_ARB_render_texture */
1279 +GLAPI BOOL GLAPIENTRY
1280 +wglSetPbufferAttribARB (HPBUFFERARB hPbuffer,
1281 + const int *piAttribList)
1282 +{
1283 + SetLastError(0);
1284 + return FALSE;
1285 +}
1286 +
1287 +GLAPI BOOL GLAPIENTRY
1288 +wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
1289 +{
1290 + SetLastError(0);
1291 + return FALSE;
1292 +}
1293 +
1294 +GLAPI BOOL GLAPIENTRY
1295 +wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
1296 +{
1297 + SetLastError(0);
1298 + return FALSE;
1299 +}
1300 +
1301 +
1302 +
1303 +
1304 Index: drivers/windows/gdi/wmesa.c
1305 ===================================================================
1306 --- drivers/windows/gdi/wmesa.c (revision 7)
1307 +++ drivers/windows/gdi/wmesa.c (working copy)
1308 @@ -1678,81 +1678,3 @@
1309 {
1310 _mesa_share_state(&ctx->gl_ctx, &ctx_to_share->gl_ctx);
1311 }
1312 -
1313 -/* This is hopefully a temporary hack to define some needed dispatch
1314 - * table entries. Hopefully, I'll find a better solution. The
1315 - * dispatch table generation scripts ought to be making these dummy
1316 - * stubs as well. */
1317 -#if !defined(__MINGW32__) || !defined(GL_NO_STDCALL)
1318 -void gl_dispatch_stub_543(void){}
1319 -void gl_dispatch_stub_544(void){}
1320 -void gl_dispatch_stub_545(void){}
1321 -void gl_dispatch_stub_546(void){}
1322 -void gl_dispatch_stub_547(void){}
1323 -void gl_dispatch_stub_548(void){}
1324 -void gl_dispatch_stub_549(void){}
1325 -void gl_dispatch_stub_550(void){}
1326 -void gl_dispatch_stub_551(void){}
1327 -void gl_dispatch_stub_552(void){}
1328 -void gl_dispatch_stub_553(void){}
1329 -void gl_dispatch_stub_554(void){}
1330 -void gl_dispatch_stub_555(void){}
1331 -void gl_dispatch_stub_556(void){}
1332 -void gl_dispatch_stub_557(void){}
1333 -void gl_dispatch_stub_558(void){}
1334 -void gl_dispatch_stub_559(void){}
1335 -void gl_dispatch_stub_560(void){}
1336 -void gl_dispatch_stub_561(void){}
1337 -void gl_dispatch_stub_565(void){}
1338 -void gl_dispatch_stub_566(void){}
1339 -void gl_dispatch_stub_577(void){}
1340 -void gl_dispatch_stub_578(void){}
1341 -void gl_dispatch_stub_603(void){}
1342 -void gl_dispatch_stub_645(void){}
1343 -void gl_dispatch_stub_646(void){}
1344 -void gl_dispatch_stub_647(void){}
1345 -void gl_dispatch_stub_648(void){}
1346 -void gl_dispatch_stub_649(void){}
1347 -void gl_dispatch_stub_650(void){}
1348 -void gl_dispatch_stub_651(void){}
1349 -void gl_dispatch_stub_652(void){}
1350 -void gl_dispatch_stub_653(void){}
1351 -void gl_dispatch_stub_733(void){}
1352 -void gl_dispatch_stub_734(void){}
1353 -void gl_dispatch_stub_735(void){}
1354 -void gl_dispatch_stub_736(void){}
1355 -void gl_dispatch_stub_737(void){}
1356 -void gl_dispatch_stub_738(void){}
1357 -void gl_dispatch_stub_744(void){}
1358 -void gl_dispatch_stub_745(void){}
1359 -void gl_dispatch_stub_746(void){}
1360 -void gl_dispatch_stub_760(void){}
1361 -void gl_dispatch_stub_761(void){}
1362 -void gl_dispatch_stub_763(void){}
1363 -void gl_dispatch_stub_765(void){}
1364 -void gl_dispatch_stub_766(void){}
1365 -void gl_dispatch_stub_767(void){}
1366 -void gl_dispatch_stub_768(void){}
1367 -
1368 -void gl_dispatch_stub_562(void){}
1369 -void gl_dispatch_stub_563(void){}
1370 -void gl_dispatch_stub_564(void){}
1371 -void gl_dispatch_stub_567(void){}
1372 -void gl_dispatch_stub_568(void){}
1373 -void gl_dispatch_stub_569(void){}
1374 -void gl_dispatch_stub_580(void){}
1375 -void gl_dispatch_stub_581(void){}
1376 -void gl_dispatch_stub_606(void){}
1377 -void gl_dispatch_stub_654(void){}
1378 -void gl_dispatch_stub_655(void){}
1379 -void gl_dispatch_stub_656(void){}
1380 -void gl_dispatch_stub_739(void){}
1381 -void gl_dispatch_stub_740(void){}
1382 -void gl_dispatch_stub_741(void){}
1383 -void gl_dispatch_stub_748(void){}
1384 -void gl_dispatch_stub_749(void){}
1385 -void gl_dispatch_stub_769(void){}
1386 -void gl_dispatch_stub_770(void){}
1387 -void gl_dispatch_stub_771(void){}
1388 -
1389 -#endif
1390 Index: drivers/windows/icd/icd.c
1391 ===================================================================
1392 --- drivers/windows/icd/icd.c (revision 7)
1393 +++ drivers/windows/icd/icd.c (working copy)
1394 @@ -1,347 +1,416 @@
1395 -/*
1396 - * Mesa 3-D graphics library
1397 - * Version: 6.1
1398 - *
1399 - * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
1400 - *
1401 - * Permission is hereby granted, free of charge, to any person obtaining a
1402 - * copy of this software and associated documentation files (the "Software"),
1403 - * to deal in the Software without restriction, including without limitation
1404 - * the rights to use, copy, modify, merge, publish, distribute, sublicense,
1405 - * and/or sell copies of the Software, and to permit persons to whom the
1406 - * Software is furnished to do so, subject to the following conditions:
1407 - *
1408 - * The above copyright notice and this permission notice shall be included
1409 - * in all copies or substantial portions of the Software.
1410 - *
1411 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
1412 - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1413 - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
1414 - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
1415 - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
1416 - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
1417 - */
1418 -
1419 -/*
1420 - * File name: icd.c
1421 - * Author: Gregor Anich
1422 - *
1423 - * ICD (Installable Client Driver) interface.
1424 - * Based on the windows GDI/WGL driver.
1425 - */
1426 -
1427 -#ifdef __cplusplus
1428 -extern "C" {
1429 -#endif
1430 -
1431 -#include <windows.h>
1432 -#define GL_GLEXT_PROTOTYPES
1433 -#include "GL/gl.h"
1434 -#include "GL/glext.h"
1435 -
1436 -#ifdef __cplusplus
1437 -}
1438 -#endif
1439 -
1440 -#include <stdio.h>
1441 -#include <tchar.h>
1442 -#include "GL/wmesa.h"
1443 -#include "mtypes.h"
1444 -#include "glapi.h"
1445 -
1446 -#define MAX_MESA_ATTRS 20
1447 -
1448 -typedef struct wmesa_context *PWMC;
1449 -
1450 -typedef struct _icdTable {
1451 - DWORD size;
1452 - PROC table[336];
1453 -} ICDTABLE, *PICDTABLE;
1454 -
1455 -#ifdef USE_MGL_NAMESPACE
1456 -# define GL_FUNC(func) mgl##func
1457 -#else
1458 -# define GL_FUNC(func) gl##func
1459 -#endif
1460 -
1461 -static ICDTABLE icdTable = { 336, {
1462 -#define ICD_ENTRY(func) (PROC)GL_FUNC(func),
1463 -#include "icdlist.h"
1464 -#undef ICD_ENTRY
1465 -} };
1466 -
1467 -struct __pixelformat__
1468 -{
1469 - PIXELFORMATDESCRIPTOR pfd;
1470 - GLboolean doubleBuffered;
1471 -};
1472 -
1473 -struct __pixelformat__ pix[] =
1474 -{
1475 - /* Double Buffer, alpha */
1476 - { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1477 - PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
1478 - PFD_TYPE_RGBA,
1479 - 24, 8, 0, 8, 8, 8, 16, 8, 24,
1480 - 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1481 - GL_TRUE
1482 - },
1483 - /* Single Buffer, alpha */
1484 - { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1485 - PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL, /* | PFD_SUPPORT_GDI ? */
1486 - PFD_TYPE_RGBA,
1487 - 24, 8, 0, 8, 8, 8, 16, 8, 24,
1488 - 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1489 - GL_FALSE
1490 - },
1491 - /* Double Buffer, no alpha */
1492 - { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1493 - PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
1494 - PFD_TYPE_RGBA,
1495 - 24, 8, 0, 8, 8, 8, 16, 0, 0,
1496 - 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1497 - GL_TRUE
1498 - },
1499 - /* Single Buffer, no alpha */
1500 - { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1501 - PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL, /* | PFD_SUPPORT_GDI ? */
1502 - PFD_TYPE_RGBA,
1503 - 24, 8, 0, 8, 8, 8, 16, 0, 0,
1504 - 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1505 - GL_FALSE
1506 - },
1507 -};
1508 -
1509 -int qt_pix = sizeof(pix) / sizeof(pix[0]);
1510 -
1511 -typedef struct {
1512 - WMesaContext ctx;
1513 - HDC hdc;
1514 -} MesaWglCtx;
1515 -
1516 -#define MESAWGL_CTX_MAX_COUNT 20
1517 -
1518 -static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];
1519 -
1520 -static unsigned ctx_count = 0;
1521 -static int ctx_current = -1;
1522 -static unsigned curPFD = 0;
1523 -
1524 -WGLAPI BOOL GLAPIENTRY DrvCopyContext(HGLRC hglrcSrc,HGLRC hglrcDst,UINT mask)
1525 -{
1526 - (void) hglrcSrc; (void) hglrcDst; (void) mask;
1527 - return(FALSE);
1528 -}
1529 -
1530 -WGLAPI HGLRC GLAPIENTRY DrvCreateContext(HDC hdc)
1531 -{
1532 - HWND hWnd;
1533 - int i = 0;
1534 -
1535 - if(!(hWnd = WindowFromDC(hdc)))
1536 - {
1537 - SetLastError(0);
1538 - return(NULL);
1539 - }
1540 - if (!ctx_count)
1541 - {
1542 - for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++)
1543 - {
1544 - wgl_ctx[i].ctx = NULL;
1545 - wgl_ctx[i].hdc = NULL;
1546 - }
1547 - }
1548 - for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
1549 - {
1550 - if ( wgl_ctx[i].ctx == NULL )
1551 - {
1552 - wgl_ctx[i].ctx = WMesaCreateContext( hWnd, NULL, GL_TRUE,
1553 - pix[curPFD-1].doubleBuffered,
1554 - pix[curPFD-1].pfd.cAlphaBits ? GL_TRUE : GL_FALSE);
1555 - if (wgl_ctx[i].ctx == NULL)
1556 - break;
1557 - wgl_ctx[i].hdc = hdc;
1558 - ctx_count++;
1559 - return ((HGLRC)wgl_ctx[i].ctx);
1560 - }
1561 - }
1562 - SetLastError(0);
1563 - return(NULL);
1564 -}
1565 -
1566 -WGLAPI BOOL GLAPIENTRY DrvDeleteContext(HGLRC hglrc)
1567 -{
1568 - int i;
1569 - for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
1570 - {
1571 - if ( wgl_ctx[i].ctx == (PWMC) hglrc )
1572 - {
1573 - WMesaMakeCurrent((PWMC) hglrc);
1574 - WMesaDestroyContext();
1575 - wgl_ctx[i].ctx = NULL;
1576 - wgl_ctx[i].hdc = NULL;
1577 - ctx_count--;
1578 - return(TRUE);
1579 - }
1580 - }
1581 - SetLastError(0);
1582 - return(FALSE);
1583 -}
1584 -
1585 -WGLAPI HGLRC GLAPIENTRY DrvCreateLayerContext(HDC hdc,int iLayerPlane)
1586 -{
1587 - if (iLayerPlane == 0)
1588 - return DrvCreateContext(hdc);
1589 - SetLastError(0);
1590 - return(NULL);
1591 -}
1592 -
1593 -WGLAPI PICDTABLE GLAPIENTRY DrvSetContext(HDC hdc,HGLRC hglrc,void *callback)
1594 -{
1595 - int i;
1596 - (void) callback;
1597 -
1598 - /* new code suggested by Andy Sy */
1599 - if (!hdc || !hglrc) {
1600 - WMesaMakeCurrent(NULL);
1601 - ctx_current = -1;
1602 - return NULL;
1603 - }
1604 -
1605 - for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
1606 - {
1607 - if ( wgl_ctx[i].ctx == (PWMC) hglrc )
1608 - {
1609 - wgl_ctx[i].hdc = hdc;
1610 - WMesaMakeCurrent( (PWMC) hglrc );
1611 - ctx_current = i;
1612 - return &icdTable;
1613 - }
1614 - }
1615 - return NULL;
1616 -}
1617 -
1618 -WGLAPI void GLAPIENTRY DrvReleaseContext(HGLRC hglrc)
1619 -{
1620 - (void) hglrc;
1621 - WMesaMakeCurrent(NULL);
1622 - ctx_current = -1;
1623 -}
1624 -
1625 -WGLAPI BOOL GLAPIENTRY DrvShareLists(HGLRC hglrc1,HGLRC hglrc2)
1626 -{
1627 - (void) hglrc1; (void) hglrc2;
1628 - return(TRUE);
1629 -}
1630 -
1631 -WGLAPI BOOL GLAPIENTRY DrvDescribeLayerPlane(HDC hdc,int iPixelFormat,
1632 - int iLayerPlane,UINT nBytes,
1633 - LPLAYERPLANEDESCRIPTOR plpd)
1634 -{
1635 - (void) hdc; (void) iPixelFormat; (void) iLayerPlane; (void) nBytes; (void) plpd;
1636 - SetLastError(0);
1637 - return(FALSE);
1638 -}
1639 -
1640 -WGLAPI int GLAPIENTRY DrvSetLayerPaletteEntries(HDC hdc,int iLayerPlane,
1641 - int iStart,int cEntries,
1642 - CONST COLORREF *pcr)
1643 -{
1644 - (void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;
1645 - SetLastError(0);
1646 - return(0);
1647 -}
1648 -
1649 -WGLAPI int GLAPIENTRY DrvGetLayerPaletteEntries(HDC hdc,int iLayerPlane,
1650 - int iStart,int cEntries,
1651 - COLORREF *pcr)
1652 -{
1653 - (void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;
1654 - SetLastError(0);
1655 - return(0);
1656 -}
1657 -
1658 -WGLAPI BOOL GLAPIENTRY DrvRealizeLayerPalette(HDC hdc,int iLayerPlane,BOOL bRealize)
1659 -{
1660 - (void) hdc; (void) iLayerPlane; (void) bRealize;
1661 - SetLastError(0);
1662 - return(FALSE);
1663 -}
1664 -
1665 -WGLAPI BOOL GLAPIENTRY DrvSwapLayerBuffers(HDC hdc,UINT fuPlanes)
1666 -{
1667 - (void) fuPlanes;
1668 - if( !hdc )
1669 - {
1670 - WMesaSwapBuffers();
1671 - return(TRUE);
1672 - }
1673 - SetLastError(0);
1674 - return(FALSE);
1675 -}
1676 -
1677 -WGLAPI int GLAPIENTRY DrvDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes,
1678 - LPPIXELFORMATDESCRIPTOR ppfd)
1679 -{
1680 - int qt_valid_pix;
1681 - (void) hdc;
1682 -
1683 - qt_valid_pix = qt_pix;
1684 - if(ppfd == NULL)
1685 - return(qt_valid_pix);
1686 - if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix || nBytes != sizeof(PIXELFORMATDESCRIPTOR))
1687 - {
1688 - SetLastError(0);
1689 - return(0);
1690 - }
1691 - *ppfd = pix[iPixelFormat - 1].pfd;
1692 - return(qt_valid_pix);
1693 -}
1694 -
1695 -/*
1696 -* GetProcAddress - return the address of an appropriate extension
1697 -*/
1698 -WGLAPI PROC GLAPIENTRY DrvGetProcAddress(LPCSTR lpszProc)
1699 -{
1700 - PROC p = (PROC) (int) _glapi_get_proc_address((const char *) lpszProc);
1701 - if (p)
1702 - return p;
1703 -
1704 - SetLastError(0);
1705 - return(NULL);
1706 -}
1707 -
1708 -WGLAPI BOOL GLAPIENTRY DrvSetPixelFormat(HDC hdc,int iPixelFormat)
1709 -{
1710 - int qt_valid_pix;
1711 - (void) hdc;
1712 -
1713 - qt_valid_pix = qt_pix;
1714 - if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix)
1715 - {
1716 - SetLastError(0);
1717 - return(FALSE);
1718 - }
1719 - curPFD = iPixelFormat;
1720 - return(TRUE);
1721 -}
1722 -
1723 -WGLAPI BOOL GLAPIENTRY DrvSwapBuffers(HDC hdc)
1724 -{
1725 - (void) hdc;
1726 - if (ctx_current < 0)
1727 - return FALSE;
1728 -
1729 - if(wgl_ctx[ctx_current].ctx == NULL) {
1730 - SetLastError(0);
1731 - return(FALSE);
1732 - }
1733 - WMesaSwapBuffers();
1734 - return(TRUE);
1735 -}
1736 -
1737 -WGLAPI BOOL GLAPIENTRY DrvValidateVersion(DWORD version)
1738 -{
1739 - (void) version;
1740 - return TRUE;
1741 -}
1742 +/*
1743 + * Mesa 3-D graphics library
1744 + * Version: 6.1
1745 + *
1746 + * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
1747 + *
1748 + * Permission is hereby granted, free of charge, to any person obtaining a
1749 + * copy of this software and associated documentation files (the "Software"),
1750 + * to deal in the Software without restriction, including without limitation
1751 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
1752 + * and/or sell copies of the Software, and to permit persons to whom the
1753 + * Software is furnished to do so, subject to the following conditions:
1754 + *
1755 + * The above copyright notice and this permission notice shall be included
1756 + * in all copies or substantial portions of the Software.
1757 + *
1758 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
1759 + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1760 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
1761 + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
1762 + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
1763 + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
1764 + */
1765 +
1766 +/*
1767 + * File name: icd.c
1768 + * Author: Gregor Anich
1769 + *
1770 + * ICD (Installable Client Driver) interface.
1771 + * Based on the windows GDI/WGL driver.
1772 + */
1773 +
1774 +#ifdef __cplusplus
1775 +extern "C" {
1776 +#endif
1777 +
1778 +#include <windows.h>
1779 +#define GL_GLEXT_PROTOTYPES
1780 +#include "GL/gl.h"
1781 +#include "GL/glext.h"
1782 +
1783 +#ifdef __cplusplus
1784 +}
1785 +#endif
1786 +
1787 +#include <stdio.h>
1788 +#include <tchar.h>
1789 +#include "GL/wmesa.h"
1790 +#include "mtypes.h"
1791 +#include "glapi.h"
1792 +
1793 +typedef void *HPBUFFERARB;
1794 +
1795 +GLAPI const char * GLAPIENTRY wglGetExtensionsStringARB(HDC hdc);
1796 +GLAPI const char * GLAPIENTRY wglGetExtensionsStringEXT (void);
1797 +GLAPI BOOL GLAPIENTRY wglChoosePixelFormatARB (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
1798 +GLAPI BOOL GLAPIENTRY wglSwapIntervalEXT (int interval);
1799 +GLAPI int GLAPIENTRY wglGetSwapIntervalEXT (void);
1800 +GLAPI BOOL GLAPIENTRY wglGetPixelFormatAttribivARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
1801 +GLAPI BOOL GLAPIENTRY wglGetPixelFormatAttribfvARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
1802 +GLAPI BOOL GLAPIENTRY wglMakeContextCurrentARB(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
1803 +GLAPI HANDLE GLAPIENTRY wglGetCurrentReadDCARB(void);
1804 +GLAPI HPBUFFERARB GLAPIENTRY wglCreatePbufferARB (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
1805 +GLAPI HDC GLAPIENTRY wglGetPbufferDCARB (HPBUFFERARB hPbuffer);
1806 +GLAPI int GLAPIENTRY wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC);
1807 +GLAPI BOOL GLAPIENTRY wglDestroyPbufferARB (HPBUFFERARB hPbuffer);
1808 +GLAPI BOOL GLAPIENTRY wglQueryPbufferARB (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
1809 +GLAPI HANDLE GLAPIENTRY wglCreateBufferRegionARB(HDC hDC, int iLayerPlane, UINT uType);
1810 +GLAPI VOID GLAPIENTRY wglDeleteBufferRegionARB(HANDLE hRegion);
1811 +GLAPI BOOL GLAPIENTRY wglSaveBufferRegionARB(HANDLE hRegion, int x, int y, int width, int height);
1812 +GLAPI BOOL GLAPIENTRY wglRestoreBufferRegionARB(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
1813 +GLAPI BOOL GLAPIENTRY wglSetPbufferAttribARB (HPBUFFERARB hPbuffer, const int *piAttribList);
1814 +GLAPI BOOL GLAPIENTRY wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
1815 +GLAPI BOOL GLAPIENTRY wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
1816 +
1817 +#define MAX_MESA_ATTRS 20
1818 +
1819 +typedef struct wmesa_context *PWMC;
1820 +
1821 +typedef struct _icdTable {
1822 + DWORD size;
1823 + PROC table[418];
1824 +} ICDTABLE, *PICDTABLE;
1825 +
1826 +#ifdef USE_MGL_NAMESPACE
1827 +# define GL_FUNC(func) mgl##func
1828 +#else
1829 +# define GL_FUNC(func) gl##func
1830 +#endif
1831 +
1832 +
1833 +static ICDTABLE icdTable = { 418, {
1834 +#define ICD_ENTRY(func) (PROC)GL_FUNC(func),
1835 +#include "icdlist.h"
1836 +#undef ICD_ENTRY
1837 +} };
1838 +
1839 +struct __pixelformat__
1840 +{
1841 + PIXELFORMATDESCRIPTOR pfd;
1842 + GLboolean doubleBuffered;
1843 +};
1844 +
1845 +struct __pixelformat__ pix[] =
1846 +{
1847 + /* Double Buffer, alpha */
1848 + { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1849 + PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
1850 + PFD_TYPE_RGBA,
1851 + 24, 8, 0, 8, 8, 8, 16, 8, 24,
1852 + 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1853 + GL_TRUE
1854 + },
1855 + /* Single Buffer, alpha */
1856 + { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1857 + PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL, /* | PFD_SUPPORT_GDI ? */
1858 + PFD_TYPE_RGBA,
1859 + 24, 8, 0, 8, 8, 8, 16, 8, 24,
1860 + 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1861 + GL_FALSE
1862 + },
1863 + /* Double Buffer, no alpha */
1864 + { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1865 + PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
1866 + PFD_TYPE_RGBA,
1867 + 24, 8, 0, 8, 8, 8, 16, 0, 0,
1868 + 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1869 + GL_TRUE
1870 + },
1871 + /* Single Buffer, no alpha */
1872 + { { sizeof(PIXELFORMATDESCRIPTOR), 1,
1873 + PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL, /* | PFD_SUPPORT_GDI ? */
1874 + PFD_TYPE_RGBA,
1875 + 24, 8, 0, 8, 8, 8, 16, 0, 0,
1876 + 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
1877 + GL_FALSE
1878 + },
1879 +};
1880 +
1881 +int qt_pix = sizeof(pix) / sizeof(pix[0]);
1882 +
1883 +typedef struct {
1884 + WMesaContext ctx;
1885 + HDC hdc;
1886 +} MesaWglCtx;
1887 +
1888 +#define MESAWGL_CTX_MAX_COUNT 20
1889 +
1890 +static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];
1891 +
1892 +static unsigned ctx_count = 0;
1893 +static int ctx_current = -1;
1894 +static unsigned curPFD = 0;
1895 +
1896 +WGLAPI BOOL GLAPIENTRY DrvCopyContext(HGLRC hglrcSrc,HGLRC hglrcDst,UINT mask)
1897 +{
1898 + (void) hglrcSrc; (void) hglrcDst; (void) mask;
1899 + return(FALSE);
1900 +}
1901 +
1902 +WGLAPI HGLRC GLAPIENTRY DrvCreateContext(HDC hdc)
1903 +{
1904 + int i = 0;
1905 +
1906 + if (!ctx_count)
1907 + {
1908 + for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++)
1909 + {
1910 + wgl_ctx[i].ctx = NULL;
1911 + wgl_ctx[i].hdc = NULL;
1912 + }
1913 + }
1914 + for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
1915 + {
1916 + if ( wgl_ctx[i].ctx == NULL )
1917 + {
1918 + wgl_ctx[i].ctx = WMesaCreateContext( hdc, NULL, GL_TRUE,
1919 + pix[curPFD-1].doubleBuffered,
1920 + pix[curPFD-1].pfd.cAlphaBits ? GL_TRUE : GL_FALSE);
1921 + if (wgl_ctx[i].ctx == NULL)
1922 + break;
1923 + wgl_ctx[i].hdc = hdc;
1924 + ctx_count++;
1925 + return ((HGLRC)wgl_ctx[i].ctx);
1926 + }
1927 + }
1928 + SetLastError(0);
1929 + return(NULL);
1930 +}
1931 +
1932 +WGLAPI BOOL GLAPIENTRY DrvDeleteContext(HGLRC hglrc)
1933 +{
1934 + int i;
1935 + for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
1936 + {
1937 + if ( wgl_ctx[i].ctx == (PWMC) hglrc )
1938 + {
1939 + WMesaMakeCurrent((PWMC) hglrc, NULL);
1940 + WMesaDestroyContext(wgl_ctx[i].ctx);
1941 + wgl_ctx[i].ctx = NULL;
1942 + wgl_ctx[i].hdc = NULL;
1943 + ctx_count--;
1944 + return(TRUE);
1945 + }
1946 + }
1947 + SetLastError(0);
1948 + return(FALSE);
1949 +}
1950 +
1951 +WGLAPI HGLRC GLAPIENTRY DrvCreateLayerContext(HDC hdc,int iLayerPlane)
1952 +{
1953 + if (iLayerPlane == 0)
1954 + return DrvCreateContext(hdc);
1955 + SetLastError(0);
1956 + return(NULL);
1957 +}
1958 +
1959 +WGLAPI PICDTABLE GLAPIENTRY DrvSetContext(HDC hdc,HGLRC hglrc,void *callback)
1960 +{
1961 + int i;
1962 + (void) callback;
1963 +
1964 + /* new code suggested by Andy Sy */
1965 + if (!hdc || !hglrc) {
1966 + WMesaMakeCurrent(NULL, NULL);
1967 + ctx_current = -1;
1968 + return NULL;
1969 + }
1970 +
1971 + for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
1972 + {
1973 + if ( wgl_ctx[i].ctx == (PWMC) hglrc )
1974 + {
1975 + wgl_ctx[i].hdc = hdc;
1976 + WMesaMakeCurrent( (PWMC) hglrc , hdc);
1977 + ctx_current = i;
1978 + return &icdTable;
1979 + }
1980 + }
1981 + return NULL;
1982 +}
1983 +
1984 +WGLAPI void GLAPIENTRY DrvReleaseContext(HGLRC hglrc)
1985 +{
1986 + (void) hglrc;
1987 + WMesaMakeCurrent(NULL, NULL);
1988 + ctx_current = -1;
1989 +}
1990 +
1991 +WGLAPI BOOL GLAPIENTRY DrvShareLists(HGLRC hglrc1,HGLRC hglrc2)
1992 +{
1993 + (void) hglrc1; (void) hglrc2;
1994 + return(TRUE);
1995 +}
1996 +
1997 +WGLAPI BOOL GLAPIENTRY DrvDescribeLayerPlane(HDC hdc,int iPixelFormat,
1998 + int iLayerPlane,UINT nBytes,
1999 + LPLAYERPLANEDESCRIPTOR plpd)
2000 +{
2001 + (void) hdc; (void) iPixelFormat; (void) iLayerPlane; (void) nBytes; (void) plpd;
2002 + SetLastError(0);
2003 + return(FALSE);
2004 +}
2005 +
2006 +WGLAPI int GLAPIENTRY DrvSetLayerPaletteEntries(HDC hdc,int iLayerPlane,
2007 + int iStart,int cEntries,
2008 + CONST COLORREF *pcr)
2009 +{
2010 + (void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;
2011 + SetLastError(0);
2012 + return(0);
2013 +}
2014 +
2015 +WGLAPI int GLAPIENTRY DrvGetLayerPaletteEntries(HDC hdc,int iLayerPlane,
2016 + int iStart,int cEntries,
2017 + COLORREF *pcr)
2018 +{
2019 + (void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;
2020 + SetLastError(0);
2021 + return(0);
2022 +}
2023 +
2024 +WGLAPI BOOL GLAPIENTRY DrvRealizeLayerPalette(HDC hdc,int iLayerPlane,BOOL bRealize)
2025 +{
2026 + (void) hdc; (void) iLayerPlane; (void) bRealize;
2027 + SetLastError(0);
2028 + return(FALSE);
2029 +}
2030 +
2031 +WGLAPI BOOL GLAPIENTRY DrvSwapLayerBuffers(HDC hdc,UINT fuPlanes)
2032 +{
2033 + (void) fuPlanes;
2034 + if( !hdc )
2035 + {
2036 + WMesaSwapBuffers(hdc);
2037 + return(TRUE);
2038 + }
2039 + SetLastError(0);
2040 + return(FALSE);
2041 +}
2042 +
2043 +WGLAPI int GLAPIENTRY DrvDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes,
2044 + LPPIXELFORMATDESCRIPTOR ppfd)
2045 +{
2046 + int qt_valid_pix;
2047 + (void) hdc;
2048 +
2049 + qt_valid_pix = qt_pix;
2050 + if( (nBytes != sizeof(PIXELFORMATDESCRIPTOR)) || (iPixelFormat < 1) || (iPixelFormat >qt_valid_pix) )
2051 + {
2052 + SetLastError(0);
2053 + return(0);
2054 + }
2055 +
2056 + if(ppfd==NULL)
2057 + {
2058 + return(qt_valid_pix);
2059 + }
2060 +
2061 + *ppfd = pix[iPixelFormat - 1].pfd;
2062 + return(qt_valid_pix);
2063 +}
2064 +
2065 +/*
2066 +* GetProcAddress - return the address of an appropriate extension
2067 +*/
2068 +
2069 +static struct {
2070 + const char *name;
2071 + PROC func;
2072 +} wgl_ext[] = {
2073 + {"wglGetExtensionsStringARB", (PROC)wglGetExtensionsStringARB},
2074 + {"wglGetExtensionsStringEXT", (PROC)wglGetExtensionsStringEXT},
2075 + {"wglSwapIntervalEXT", (PROC)wglSwapIntervalEXT},
2076 + {"wglGetSwapIntervalEXT", (PROC)wglGetSwapIntervalEXT},
2077 + {"wglGetPixelFormatAttribivARB", (PROC)wglGetPixelFormatAttribivARB},
2078 + {"wglGetPixelFormatAttribfvARB", (PROC)wglGetPixelFormatAttribfvARB},
2079 + {"wglChoosePixelFormatARB", (PROC)wglChoosePixelFormatARB},
2080 + {"wglCreatePbufferARB", (PROC)wglCreatePbufferARB},
2081 + {"wglGetPbufferDCARB", (PROC)wglGetPbufferDCARB},
2082 + {"wglReleasePbufferDCARB", (PROC)wglReleasePbufferDCARB},
2083 + {"wglDestroyPbufferARB", (PROC)wglDestroyPbufferARB},
2084 + {"wglQueryPbufferARB", (PROC)wglQueryPbufferARB},
2085 + {"wglSetPbufferAttribARB", (PROC)wglSetPbufferAttribARB},
2086 + {"wglBindTexImageARB", (PROC)wglBindTexImageARB},
2087 + {"wglReleaseTexImageARB", (PROC)wglReleaseTexImageARB},
2088 + {"wglCreateBufferRegionARB", (PROC)wglCreateBufferRegionARB},
2089 + {"wglDeleteBufferRegionARB", (PROC)wglDeleteBufferRegionARB},
2090 + {"wglSaveBufferRegionARB", (PROC)wglSaveBufferRegionARB},
2091 + {"wglRestoreBufferRegionARB", (PROC)wglRestoreBufferRegionARB},
2092 + {"wglMakeContextCurrentARB", (PROC)wglMakeContextCurrentARB},
2093 + {"wglGetCurrentReadDCARB", (PROC)wglGetCurrentReadDCARB},
2094 + {NULL, NULL}
2095 +};
2096 +
2097 +WGLAPI PROC GLAPIENTRY DrvGetProcAddress(LPCSTR lpszProc)
2098 +{
2099 + int i;
2100 + PROC p = (PROC) _glapi_get_proc_address((const char *) lpszProc);
2101 + if (p)
2102 + return p;
2103 +
2104 + for (i = 0; wgl_ext[i].name; i++)
2105 + {
2106 + if (!strcmp(lpszProc, wgl_ext[i].name))
2107 + {
2108 + return wgl_ext[i].func;
2109 + }
2110 + }
2111 +
2112 + SetLastError(0);
2113 + return(NULL);
2114 +}
2115 +
2116 +WGLAPI BOOL GLAPIENTRY DrvSetPixelFormat(HDC hdc,int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
2117 +{
2118 + int qt_valid_pix;
2119 +
2120 + qt_valid_pix = qt_pix;
2121 +
2122 + if (iPixelFormat < 1 || iPixelFormat > qt_valid_pix) {
2123 + if (ppfd == NULL) {
2124 + PIXELFORMATDESCRIPTOR my_pfd;
2125 + if (!DrvDescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &my_pfd)) {
2126 + SetLastError(0);
2127 + return FALSE;
2128 + }
2129 + } else if (ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR)) {
2130 + SetLastError(0);
2131 + return FALSE;
2132 + }
2133 + }
2134 + curPFD = iPixelFormat;
2135 +
2136 + return TRUE;
2137 +}
2138 +
2139 +WGLAPI BOOL GLAPIENTRY DrvSwapBuffers(HDC hdc)
2140 +{
2141 + (void) hdc;
2142 + if (ctx_current < 0)
2143 + return FALSE;
2144 +
2145 + if(wgl_ctx[ctx_current].ctx == NULL) {
2146 + SetLastError(0);
2147 + return(FALSE);
2148 + }
2149 + WMesaSwapBuffers(hdc);
2150 + return(TRUE);
2151 +}
2152 +
2153 +WGLAPI BOOL GLAPIENTRY DrvValidateVersion(DWORD version)
2154 +{
2155 + (void) version;
2156 + return TRUE;
2157 +}
2158 Index: drivers/windows/icd/icdlist.h
2159 ===================================================================
2160 --- drivers/windows/icd/icdlist.h (revision 7)
2161 +++ drivers/windows/icd/icdlist.h (working copy)
2162 @@ -1,336 +1,424 @@
2163 -ICD_ENTRY(NewList) /* 0 */
2164 -ICD_ENTRY(EndList) /* 1 */
2165 -ICD_ENTRY(CallList) /* 2 */
2166 -ICD_ENTRY(CallLists) /* 3 */
2167 -ICD_ENTRY(DeleteLists) /* 4 */
2168 -ICD_ENTRY(GenLists) /* 5 */
2169 -ICD_ENTRY(ListBase) /* 6 */
2170 -ICD_ENTRY(Begin) /* 7 */
2171 -ICD_ENTRY(Bitmap) /* 8 */
2172 -ICD_ENTRY(Color3b) /* 9 */
2173 -ICD_ENTRY(Color3bv) /* 10 */
2174 -ICD_ENTRY(Color3d) /* 11 */
2175 -ICD_ENTRY(Color3dv) /* 12 */
2176 -ICD_ENTRY(Color3f) /* 13 */
2177 -ICD_ENTRY(Color3fv) /* 14 */
2178 -ICD_ENTRY(Color3i) /* 15 */
2179 -ICD_ENTRY(Color3iv) /* 16 */
2180 -ICD_ENTRY(Color3s) /* 17 */
2181 -ICD_ENTRY(Color3sv) /* 18 */
2182 -ICD_ENTRY(Color3ub) /* 19 */
2183 -ICD_ENTRY(Color3ubv) /* 20 */
2184 -ICD_ENTRY(Color3ui) /* 21 */
2185 -ICD_ENTRY(Color3uiv) /* 22 */
2186 -ICD_ENTRY(Color3us) /* 23 */
2187 -ICD_ENTRY(Color3usv) /* 24 */
2188 -ICD_ENTRY(Color4b) /* 25 */
2189 -ICD_ENTRY(Color4bv) /* 26 */
2190 -ICD_ENTRY(Color4d) /* 27 */
2191 -ICD_ENTRY(Color4dv) /* 28 */
2192 -ICD_ENTRY(Color4f) /* 29 */
2193 -ICD_ENTRY(Color4fv) /* 30 */
2194 -ICD_ENTRY(Color4i) /* 31 */
2195 -ICD_ENTRY(Color4iv) /* 32 */
2196 -ICD_ENTRY(Color4s) /* 33 */
2197 -ICD_ENTRY(Color4sv) /* 34 */
2198 -ICD_ENTRY(Color4ub) /* 35 */
2199 -ICD_ENTRY(Color4ubv) /* 36 */
2200 -ICD_ENTRY(Color4ui) /* 37 */
2201 -ICD_ENTRY(Color4uiv) /* 38 */
2202 -ICD_ENTRY(Color4us) /* 39 */
2203 -ICD_ENTRY(Color4usv) /* 40 */
2204 -ICD_ENTRY(EdgeFlag) /* 41 */
2205 -ICD_ENTRY(EdgeFlagv) /* 42 */
2206 -ICD_ENTRY(End) /* 43 */
2207 -ICD_ENTRY(Indexd) /* 44 */
2208 -ICD_ENTRY(Indexdv) /* 45 */
2209 -ICD_ENTRY(Indexf) /* 46 */
2210 -ICD_ENTRY(Indexfv) /* 47 */
2211 -ICD_ENTRY(Indexi) /* 48 */
2212 -ICD_ENTRY(Indexiv) /* 49 */
2213 -ICD_ENTRY(Indexs) /* 50 */
2214 -ICD_ENTRY(Indexsv) /* 51 */
2215 -ICD_ENTRY(Normal3b) /* 52 */
2216 -ICD_ENTRY(Normal3bv) /* 53 */
2217 -ICD_ENTRY(Normal3d) /* 54 */
2218 -ICD_ENTRY(Normal3dv) /* 55 */
2219 -ICD_ENTRY(Normal3f) /* 56 */
2220 -ICD_ENTRY(Normal3fv) /* 57 */
2221 -ICD_ENTRY(Normal3i) /* 58 */
2222 -ICD_ENTRY(Normal3iv) /* 59 */
2223 -ICD_ENTRY(Normal3s) /* 60 */
2224 -ICD_ENTRY(Normal3sv) /* 61 */
2225 -ICD_ENTRY(RasterPos2d) /* 62 */
2226 -ICD_ENTRY(RasterPos2dv) /* 63 */
2227 -ICD_ENTRY(RasterPos2f) /* 64 */
2228 -ICD_ENTRY(RasterPos2fv) /* 65 */
2229 -ICD_ENTRY(RasterPos2i) /* 66 */
2230 -ICD_ENTRY(RasterPos2iv) /* 67 */
2231 -ICD_ENTRY(RasterPos2s) /* 68 */
2232 -ICD_ENTRY(RasterPos2sv) /* 69 */
2233 -ICD_ENTRY(RasterPos3d) /* 70 */
2234 -ICD_ENTRY(RasterPos3dv) /* 71 */
2235 -ICD_ENTRY(RasterPos3f) /* 72 */
2236 -ICD_ENTRY(RasterPos3fv) /* 73 */
2237 -ICD_ENTRY(RasterPos3i) /* 74 */
2238 -ICD_ENTRY(RasterPos3iv) /* 75 */
2239 -ICD_ENTRY(RasterPos3s) /* 76 */
2240 -ICD_ENTRY(RasterPos3sv) /* 77 */
2241 -ICD_ENTRY(RasterPos4d) /* 78 */
2242 -ICD_ENTRY(RasterPos4dv) /* 79 */
2243 -ICD_ENTRY(RasterPos4f) /* 80 */
2244 -ICD_ENTRY(RasterPos4fv) /* 81 */
2245 -ICD_ENTRY(RasterPos4i) /* 82 */
2246 -ICD_ENTRY(RasterPos4iv) /* 83 */
2247 -ICD_ENTRY(RasterPos4s) /* 84 */
2248 -ICD_ENTRY(RasterPos4sv) /* 85 */
2249 -ICD_ENTRY(Rectd) /* 86 */
2250 -ICD_ENTRY(Rectdv) /* 87 */
2251 -ICD_ENTRY(Rectf) /* 88 */
2252 -ICD_ENTRY(Rectfv) /* 89 */
2253 -ICD_ENTRY(Recti) /* 90 */
2254 -ICD_ENTRY(Rectiv) /* 91 */
2255 -ICD_ENTRY(Rects) /* 92 */
2256 -ICD_ENTRY(Rectsv) /* 93 */
2257 -ICD_ENTRY(TexCoord1d) /* 94 */
2258 -ICD_ENTRY(TexCoord1dv) /* 95 */
2259 -ICD_ENTRY(TexCoord1f) /* 96 */
2260 -ICD_ENTRY(TexCoord1fv) /* 97 */
2261 -ICD_ENTRY(TexCoord1i) /* 98 */
2262 -ICD_ENTRY(TexCoord1iv) /* 99 */
2263 -ICD_ENTRY(TexCoord1s) /* 100 */
2264 -ICD_ENTRY(TexCoord1sv) /* 101 */
2265 -ICD_ENTRY(TexCoord2d) /* 102 */
2266 -ICD_ENTRY(TexCoord2dv) /* 103 */
2267 -ICD_ENTRY(TexCoord2f) /* 104 */
2268 -ICD_ENTRY(TexCoord2fv) /* 105 */
2269 -ICD_ENTRY(TexCoord2i) /* 106 */
2270 -ICD_ENTRY(TexCoord2iv) /* 107 */
2271 -ICD_ENTRY(TexCoord2s) /* 108 */
2272 -ICD_ENTRY(TexCoord2sv) /* 109 */
2273 -ICD_ENTRY(TexCoord3d) /* 110 */
2274 -ICD_ENTRY(TexCoord3dv) /* 111 */
2275 -ICD_ENTRY(TexCoord3f) /* 112 */
2276 -ICD_ENTRY(TexCoord3fv) /* 113 */
2277 -ICD_ENTRY(TexCoord3i) /* 114 */
2278 -ICD_ENTRY(TexCoord3iv) /* 115 */
2279 -ICD_ENTRY(TexCoord3s) /* 116 */
2280 -ICD_ENTRY(TexCoord3sv) /* 117 */
2281 -ICD_ENTRY(TexCoord4d) /* 118 */
2282 -ICD_ENTRY(TexCoord4dv) /* 119 */
2283 -ICD_ENTRY(TexCoord4f) /* 120 */
2284 -ICD_ENTRY(TexCoord4fv) /* 121 */
2285 -ICD_ENTRY(TexCoord4i) /* 122 */
2286 -ICD_ENTRY(TexCoord4iv) /* 123 */
2287 -ICD_ENTRY(TexCoord4s) /* 124 */
2288 -ICD_ENTRY(TexCoord4sv) /* 125 */
2289 -ICD_ENTRY(Vertex2d) /* 126 */
2290 -ICD_ENTRY(Vertex2dv) /* 127 */
2291 -ICD_ENTRY(Vertex2f) /* 128 */
2292 -ICD_ENTRY(Vertex2fv) /* 129 */
2293 -ICD_ENTRY(Vertex2i) /* 130 */
2294 -ICD_ENTRY(Vertex2iv) /* 131 */
2295 -ICD_ENTRY(Vertex2s) /* 132 */
2296 -ICD_ENTRY(Vertex2sv) /* 133 */
2297 -ICD_ENTRY(Vertex3d) /* 134 */
2298 -ICD_ENTRY(Vertex3dv) /* 135 */
2299 -ICD_ENTRY(Vertex3f) /* 136 */
2300 -ICD_ENTRY(Vertex3fv) /* 137 */
2301 -ICD_ENTRY(Vertex3i) /* 138 */
2302 -ICD_ENTRY(Vertex3iv) /* 139 */
2303 -ICD_ENTRY(Vertex3s) /* 140 */
2304 -ICD_ENTRY(Vertex3sv) /* 141 */
2305 -ICD_ENTRY(Vertex4d) /* 142 */
2306 -ICD_ENTRY(Vertex4dv) /* 143 */
2307 -ICD_ENTRY(Vertex4f) /* 144 */
2308 -ICD_ENTRY(Vertex4fv) /* 145 */
2309 -ICD_ENTRY(Vertex4i) /* 146 */
2310 -ICD_ENTRY(Vertex4iv) /* 147 */
2311 -ICD_ENTRY(Vertex4s) /* 148 */
2312 -ICD_ENTRY(Vertex4sv) /* 149 */
2313 -ICD_ENTRY(ClipPlane) /* 150 */
2314 -ICD_ENTRY(ColorMaterial) /* 151 */
2315 -ICD_ENTRY(CullFace) /* 152 */
2316 -ICD_ENTRY(Fogf) /* 153 */
2317 -ICD_ENTRY(Fogfv) /* 154 */
2318 -ICD_ENTRY(Fogi) /* 155 */
2319 -ICD_ENTRY(Fogiv) /* 156 */
2320 -ICD_ENTRY(FrontFace) /* 157 */
2321 -ICD_ENTRY(Hint) /* 158 */
2322 -ICD_ENTRY(Lightf) /* 159 */
2323 -ICD_ENTRY(Lightfv) /* 160 */
2324 -ICD_ENTRY(Lighti) /* 161 */
2325 -ICD_ENTRY(Lightiv) /* 162 */
2326 -ICD_ENTRY(LightModelf) /* 163 */
2327 -ICD_ENTRY(LightModelfv) /* 164 */
2328 -ICD_ENTRY(LightModeli) /* 165 */
2329 -ICD_ENTRY(LightModeliv) /* 166 */
2330 -ICD_ENTRY(LineStipple) /* 167 */
2331 -ICD_ENTRY(LineWidth) /* 168 */
2332 -ICD_ENTRY(Materialf) /* 169 */
2333 -ICD_ENTRY(Materialfv) /* 170 */
2334 -ICD_ENTRY(Materiali) /* 171 */
2335 -ICD_ENTRY(Materialiv) /* 172 */
2336 -ICD_ENTRY(PointSize) /* 173 */
2337 -ICD_ENTRY(PolygonMode) /* 174 */
2338 -ICD_ENTRY(PolygonStipple) /* 175 */
2339 -ICD_ENTRY(Scissor) /* 176 */
2340 -ICD_ENTRY(ShadeModel) /* 177 */
2341 -ICD_ENTRY(TexParameterf) /* 178 */
2342 -ICD_ENTRY(TexParameterfv) /* 179 */
2343 -ICD_ENTRY(TexParameteri) /* 180 */
2344 -ICD_ENTRY(TexParameteriv) /* 181 */
2345 -ICD_ENTRY(TexImage1D) /* 182 */
2346 -ICD_ENTRY(TexImage2D) /* 183 */
2347 -ICD_ENTRY(TexEnvf) /* 184 */
2348 -ICD_ENTRY(TexEnvfv) /* 185 */
2349 -ICD_ENTRY(TexEnvi) /* 186 */
2350 -ICD_ENTRY(TexEnviv) /* 187 */
2351 -ICD_ENTRY(TexGend) /* 188 */
2352 -ICD_ENTRY(TexGendv) /* 189 */
2353 -ICD_ENTRY(TexGenf) /* 190 */
2354 -ICD_ENTRY(TexGenfv) /* 191 */
2355 -ICD_ENTRY(TexGeni) /* 192 */
2356 -ICD_ENTRY(TexGeniv) /* 193 */
2357 -ICD_ENTRY(FeedbackBuffer) /* 194 */
2358 -ICD_ENTRY(SelectBuffer) /* 195 */
2359 -ICD_ENTRY(RenderMode) /* 196 */
2360 -ICD_ENTRY(InitNames) /* 197 */
2361 -ICD_ENTRY(LoadName) /* 198 */
2362 -ICD_ENTRY(PassThrough) /* 199 */
2363 -ICD_ENTRY(PopName) /* 200 */
2364 -ICD_ENTRY(PushName) /* 201 */
2365 -ICD_ENTRY(DrawBuffer) /* 202 */
2366 -ICD_ENTRY(Clear) /* 203 */
2367 -ICD_ENTRY(ClearAccum) /* 204 */
2368 -ICD_ENTRY(ClearIndex) /* 205 */
2369 -ICD_ENTRY(ClearColor) /* 206 */
2370 -ICD_ENTRY(ClearStencil) /* 207 */
2371 -ICD_ENTRY(ClearDepth) /* 208 */
2372 -ICD_ENTRY(StencilMask) /* 209 */
2373 -ICD_ENTRY(ColorMask) /* 210 */
2374 -ICD_ENTRY(DepthMask) /* 211 */
2375 -ICD_ENTRY(IndexMask) /* 212 */
2376 -ICD_ENTRY(Accum) /* 213 */
2377 -ICD_ENTRY(Disable) /* 214 */
2378 -ICD_ENTRY(Enable) /* 215 */
2379 -ICD_ENTRY(Finish) /* 216 */
2380 -ICD_ENTRY(Flush) /* 217 */
2381 -ICD_ENTRY(PopAttrib) /* 218 */
2382 -ICD_ENTRY(PushAttrib) /* 219 */
2383 -ICD_ENTRY(Map1d) /* 220 */
2384 -ICD_ENTRY(Map1f) /* 221 */
2385 -ICD_ENTRY(Map2d) /* 222 */
2386 -ICD_ENTRY(Map2f) /* 223 */
2387 -ICD_ENTRY(MapGrid1d) /* 224 */
2388 -ICD_ENTRY(MapGrid1f) /* 225 */
2389 -ICD_ENTRY(MapGrid2d) /* 226 */
2390 -ICD_ENTRY(MapGrid2f) /* 227 */
2391 -ICD_ENTRY(EvalCoord1d) /* 228 */
2392 -ICD_ENTRY(EvalCoord1dv) /* 229 */
2393 -ICD_ENTRY(EvalCoord1f) /* 230 */
2394 -ICD_ENTRY(EvalCoord1fv) /* 231 */
2395 -ICD_ENTRY(EvalCoord2d) /* 232 */
2396 -ICD_ENTRY(EvalCoord2dv) /* 233 */
2397 -ICD_ENTRY(EvalCoord2f) /* 234 */
2398 -ICD_ENTRY(EvalCoord2fv) /* 235 */
2399 -ICD_ENTRY(EvalMesh1) /* 236 */
2400 -ICD_ENTRY(EvalPoint1) /* 237 */
2401 -ICD_ENTRY(EvalMesh2) /* 238 */
2402 -ICD_ENTRY(EvalPoint2) /* 239 */
2403 -ICD_ENTRY(AlphaFunc) /* 240 */
2404 -ICD_ENTRY(BlendFunc) /* 241 */
2405 -ICD_ENTRY(LogicOp) /* 242 */
2406 -ICD_ENTRY(StencilFunc) /* 243 */
2407 -ICD_ENTRY(StencilOp) /* 244 */
2408 -ICD_ENTRY(DepthFunc) /* 245 */
2409 -ICD_ENTRY(PixelZoom) /* 246 */
2410 -ICD_ENTRY(PixelTransferf) /* 247 */
2411 -ICD_ENTRY(PixelTransferi) /* 248 */
2412 -ICD_ENTRY(PixelStoref) /* 249 */
2413 -ICD_ENTRY(PixelStorei) /* 250 */
2414 -ICD_ENTRY(PixelMapfv) /* 251 */
2415 -ICD_ENTRY(PixelMapuiv) /* 252 */
2416 -ICD_ENTRY(PixelMapusv) /* 253 */
2417 -ICD_ENTRY(ReadBuffer) /* 254 */
2418 -ICD_ENTRY(CopyPixels) /* 255 */
2419 -ICD_ENTRY(ReadPixels) /* 256 */
2420 -ICD_ENTRY(DrawPixels) /* 257 */
2421 -ICD_ENTRY(GetBooleanv) /* 258 */
2422 -ICD_ENTRY(GetClipPlane) /* 259 */
2423 -ICD_ENTRY(GetDoublev) /* 260 */
2424 -ICD_ENTRY(GetError) /* 261 */
2425 -ICD_ENTRY(GetFloatv) /* 262 */
2426 -ICD_ENTRY(GetIntegerv) /* 263 */
2427 -ICD_ENTRY(GetLightfv) /* 264 */
2428 -ICD_ENTRY(GetLightiv) /* 265 */
2429 -ICD_ENTRY(GetMapdv) /* 266 */
2430 -ICD_ENTRY(GetMapfv) /* 267 */
2431 -ICD_ENTRY(GetMapiv) /* 268 */
2432 -ICD_ENTRY(GetMaterialfv) /* 269 */
2433 -ICD_ENTRY(GetMaterialiv) /* 270 */
2434 -ICD_ENTRY(GetPixelMapfv) /* 271 */
2435 -ICD_ENTRY(GetPixelMapuiv) /* 272 */
2436 -ICD_ENTRY(GetPixelMapusv) /* 273 */
2437 -ICD_ENTRY(GetPolygonStipple) /* 274 */
2438 -ICD_ENTRY(GetString) /* 275 */
2439 -ICD_ENTRY(GetTexEnvfv) /* 276 */
2440 -ICD_ENTRY(GetTexEnviv) /* 277 */
2441 -ICD_ENTRY(GetTexGendv) /* 278 */
2442 -ICD_ENTRY(GetTexGenfv) /* 279 */
2443 -ICD_ENTRY(GetTexGeniv) /* 280 */
2444 -ICD_ENTRY(GetTexImage) /* 281 */
2445 -ICD_ENTRY(GetTexParameterfv) /* 282 */
2446 -ICD_ENTRY(GetTexParameteriv) /* 283 */
2447 -ICD_ENTRY(GetTexLevelParameterfv) /* 284 */
2448 -ICD_ENTRY(GetTexLevelParameteriv) /* 285 */
2449 -ICD_ENTRY(IsEnabled) /* 286 */
2450 -ICD_ENTRY(IsList) /* 287 */
2451 -ICD_ENTRY(DepthRange) /* 288 */
2452 -ICD_ENTRY(Frustum) /* 289 */
2453 -ICD_ENTRY(LoadIdentity) /* 290 */
2454 -ICD_ENTRY(LoadMatrixf) /* 291 */
2455 -ICD_ENTRY(LoadMatrixd) /* 292 */
2456 -ICD_ENTRY(MatrixMode) /* 293 */
2457 -ICD_ENTRY(MultMatrixf) /* 294 */
2458 -ICD_ENTRY(MultMatrixd) /* 295 */
2459 -ICD_ENTRY(Ortho) /* 296 */
2460 -ICD_ENTRY(PopMatrix) /* 297 */
2461 -ICD_ENTRY(PushMatrix) /* 298 */
2462 -ICD_ENTRY(Rotated) /* 299 */
2463 -ICD_ENTRY(Rotatef) /* 300 */
2464 -ICD_ENTRY(Scaled) /* 301 */
2465 -ICD_ENTRY(Scalef) /* 302 */
2466 -ICD_ENTRY(Translated) /* 303 */
2467 -ICD_ENTRY(Translatef) /* 304 */
2468 -ICD_ENTRY(Viewport) /* 305 */
2469 -ICD_ENTRY(ArrayElement) /* 306 */
2470 -ICD_ENTRY(BindTexture) /* 307 */
2471 -ICD_ENTRY(ColorPointer) /* 308 */
2472 -ICD_ENTRY(DisableClientState) /* 309 */
2473 -ICD_ENTRY(DrawArrays) /* 310 */
2474 -ICD_ENTRY(DrawElements) /* 311 */
2475 -ICD_ENTRY(EdgeFlagPointer) /* 312 */
2476 -ICD_ENTRY(EnableClientState) /* 313 */
2477 -ICD_ENTRY(IndexPointer) /* 314 */
2478 -ICD_ENTRY(Indexub) /* 315 */
2479 -ICD_ENTRY(Indexubv) /* 316 */
2480 -ICD_ENTRY(InterleavedArrays) /* 317 */
2481 -ICD_ENTRY(NormalPointer) /* 318 */
2482 -ICD_ENTRY(PolygonOffset) /* 319 */
2483 -ICD_ENTRY(TexCoordPointer) /* 320 */
2484 -ICD_ENTRY(VertexPointer) /* 321 */
2485 -ICD_ENTRY(AreTexturesResident) /* 322 */
2486 -ICD_ENTRY(CopyTexImage1D) /* 323 */
2487 -ICD_ENTRY(CopyTexImage2D) /* 324 */
2488 -ICD_ENTRY(CopyTexSubImage1D) /* 325 */
2489 -ICD_ENTRY(CopyTexSubImage2D) /* 326 */
2490 -ICD_ENTRY(DeleteTextures) /* 327 */
2491 -ICD_ENTRY(GenTextures) /* 328 */
2492 -ICD_ENTRY(GetPointerv) /* 329 */
2493 -ICD_ENTRY(IsTexture) /* 330 */
2494 -ICD_ENTRY(PrioritizeTextures) /* 331 */
2495 -ICD_ENTRY(TexSubImage1D) /* 332 */
2496 -ICD_ENTRY(TexSubImage2D) /* 333 */
2497 -ICD_ENTRY(PopClientAttrib) /* 334 */
2498 -ICD_ENTRY(PushClientAttrib) /* 335 */
2499 +/* OpenGL version 1.0 */
2500 +ICD_ENTRY(NewList) /* 000 "glNewList" */
2501 +ICD_ENTRY(EndList) /* 001 "glEndList" */
2502 +ICD_ENTRY(CallList) /* 002 "glCallList" */
2503 +ICD_ENTRY(CallLists) /* 003 "glCallLists" */
2504 +ICD_ENTRY(DeleteLists) /* 004 "glDeleteLists" */
2505 +ICD_ENTRY(GenLists) /* 005 "glGenLists" */
2506 +ICD_ENTRY(ListBase) /* 006 "glListBase" */
2507 +ICD_ENTRY(Begin) /* 007 "glBegin" */
2508 +ICD_ENTRY(Bitmap) /* 008 "glBitmap" */
2509 +ICD_ENTRY(Color3b) /* 009 "glColor3b" */
2510 +ICD_ENTRY(Color3bv) /* 010 "glColor3bv" */
2511 +ICD_ENTRY(Color3d) /* 011 "glColor3d" */
2512 +ICD_ENTRY(Color3dv) /* 012 "glColor3dv" */
2513 +ICD_ENTRY(Color3f) /* 013 "glColor3f" */
2514 +ICD_ENTRY(Color3fv) /* 014 "glColor3fv" */
2515 +ICD_ENTRY(Color3i) /* 015 "glColor3i" */
2516 +ICD_ENTRY(Color3iv) /* 016 "glColor3iv" */
2517 +ICD_ENTRY(Color3s) /* 017 "glColor3s" */
2518 +ICD_ENTRY(Color3sv) /* 018 "glColor3sv" */
2519 +ICD_ENTRY(Color3ub) /* 019 "glColor3ub" */
2520 +ICD_ENTRY(Color3ubv) /* 020 "glColor3ubv" */
2521 +ICD_ENTRY(Color3ui) /* 021 "glColor3ui" */
2522 +ICD_ENTRY(Color3uiv) /* 022 "glColor3uiv" */
2523 +ICD_ENTRY(Color3us) /* 023 "glColor3us" */
2524 +ICD_ENTRY(Color3usv) /* 024 "glColor3usv" */
2525 +ICD_ENTRY(Color4b) /* 025 "glColor4b" */
2526 +ICD_ENTRY(Color4bv) /* 026 "glColor4bv" */
2527 +ICD_ENTRY(Color4d) /* 027 "glColor4d" */
2528 +ICD_ENTRY(Color4dv) /* 028 "glColor4dv" */
2529 +ICD_ENTRY(Color4f) /* 029 "glColor4f" */
2530 +ICD_ENTRY(Color4fv) /* 030 "glColor4fv" */
2531 +ICD_ENTRY(Color4i) /* 031 "glColor4i" */
2532 +ICD_ENTRY(Color4iv) /* 032 "glColor4iv" */
2533 +ICD_ENTRY(Color4s) /* 033 "glColor4s" */
2534 +ICD_ENTRY(Color4sv) /* 034 "glColor4sv" */
2535 +ICD_ENTRY(Color4ub) /* 035 "glColor4ub" */
2536 +ICD_ENTRY(Color4ubv) /* 036 "glColor4ubv" */
2537 +ICD_ENTRY(Color4ui) /* 037 "glColor4ui" */
2538 +ICD_ENTRY(Color4uiv) /* 038 "glColor4uiv" */
2539 +ICD_ENTRY(Color4us) /* 039 "glColor4us" */
2540 +ICD_ENTRY(Color4usv) /* 040 "glColor4usv" */
2541 +ICD_ENTRY(EdgeFlag) /* 041 "glEdgeFlag" */
2542 +ICD_ENTRY(EdgeFlagv) /* 042 "glEdgeFlagv" */
2543 +ICD_ENTRY(End) /* 043 "glEnd" */
2544 +ICD_ENTRY(Indexd) /* 044 "glIndexd" */
2545 +ICD_ENTRY(Indexdv) /* 045 "glIndexdv" */
2546 +ICD_ENTRY(Indexf) /* 046 "glIndexf" */
2547 +ICD_ENTRY(Indexfv) /* 047 "glIndexfv" */
2548 +ICD_ENTRY(Indexi) /* 048 "glIndexi" */
2549 +ICD_ENTRY(Indexiv) /* 049 "glIndexiv" */
2550 +ICD_ENTRY(Indexs) /* 050 "glIndexs" */
2551 +ICD_ENTRY(Indexsv) /* 051 "glIndexsv" */
2552 +ICD_ENTRY(Normal3b) /* 052 "glNormal3b" */
2553 +ICD_ENTRY(Normal3bv) /* 053 "glNormal3bv" */
2554 +ICD_ENTRY(Normal3d) /* 054 "glNormal3d" */
2555 +ICD_ENTRY(Normal3dv) /* 055 "glNormal3dv" */
2556 +ICD_ENTRY(Normal3f) /* 056 "glNormal3f" */
2557 +ICD_ENTRY(Normal3fv) /* 057 "glNormal3fv" */
2558 +ICD_ENTRY(Normal3i) /* 058 "glNormal3i" */
2559 +ICD_ENTRY(Normal3iv) /* 059 "glNormal3iv" */
2560 +ICD_ENTRY(Normal3s) /* 060 "glNormal3s" */
2561 +ICD_ENTRY(Normal3sv) /* 061 "glNormal3sv" */
2562 +ICD_ENTRY(RasterPos2d) /* 062 "glRasterPos2d" */
2563 +ICD_ENTRY(RasterPos2dv) /* 063 "glRasterPos2dv" */
2564 +ICD_ENTRY(RasterPos2f) /* 064 "glRasterPos2f" */
2565 +ICD_ENTRY(RasterPos2fv) /* 065 "glRasterPos2fv" */
2566 +ICD_ENTRY(RasterPos2i) /* 066 "glRasterPos2i" */
2567 +ICD_ENTRY(RasterPos2iv) /* 067 "glRasterPos2iv" */
2568 +ICD_ENTRY(RasterPos2s) /* 068 "glRasterPos2s" */
2569 +ICD_ENTRY(RasterPos2sv) /* 069 "glRasterPos2sv" */
2570 +ICD_ENTRY(RasterPos3d) /* 070 "glRasterPos3d" */
2571 +ICD_ENTRY(RasterPos3dv) /* 071 "glRasterPos3dv" */
2572 +ICD_ENTRY(RasterPos3f) /* 072 "glRasterPos3f" */
2573 +ICD_ENTRY(RasterPos3fv) /* 073 "glRasterPos3fv" */
2574 +ICD_ENTRY(RasterPos3i) /* 074 "glRasterPos3i" */
2575 +ICD_ENTRY(RasterPos3iv) /* 075 "glRasterPos3iv" */
2576 +ICD_ENTRY(RasterPos3s) /* 076 "glRasterPos3s" */
2577 +ICD_ENTRY(RasterPos3sv) /* 077 "glRasterPos3sv" */
2578 +ICD_ENTRY(RasterPos4d) /* 078 "glRasterPos4d" */
2579 +ICD_ENTRY(RasterPos4dv) /* 079 "glRasterPos4dv" */
2580 +ICD_ENTRY(RasterPos4f) /* 080 "glRasterPos4f" */
2581 +ICD_ENTRY(RasterPos4fv) /* 081 "glRasterPos4fv" */
2582 +ICD_ENTRY(RasterPos4i) /* 082 "glRasterPos4i" */
2583 +ICD_ENTRY(RasterPos4iv) /* 083 "glRasterPos4iv" */
2584 +ICD_ENTRY(RasterPos4s) /* 084 "glRasterPos4s" */
2585 +ICD_ENTRY(RasterPos4sv) /* 085 "glRasterPos4sv" */
2586 +ICD_ENTRY(Rectd) /* 086 "glRectd" */
2587 +ICD_ENTRY(Rectdv) /* 087 "glRectdv" */
2588 +ICD_ENTRY(Rectf) /* 088 "glRectf" */
2589 +ICD_ENTRY(Rectfv) /* 089 "glRectfv" */
2590 +ICD_ENTRY(Recti) /* 090 "glRecti" */
2591 +ICD_ENTRY(Rectiv) /* 091 "glRectiv" */
2592 +ICD_ENTRY(Rects) /* 092 "glRects" */
2593 +ICD_ENTRY(Rectsv) /* 093 "glRectsv" */
2594 +ICD_ENTRY(TexCoord1d) /* 094 "glTexCoord1d" */
2595 +ICD_ENTRY(TexCoord1dv) /* 095 "glTexCoord1dv" */
2596 +ICD_ENTRY(TexCoord1f) /* 096 "glTexCoord1f" */
2597 +ICD_ENTRY(TexCoord1fv) /* 097 "glTexCoord1fv" */
2598 +ICD_ENTRY(TexCoord1i) /* 098 "glTexCoord1i" */
2599 +ICD_ENTRY(TexCoord1iv) /* 099 "glTexCoord1iv" */
2600 +ICD_ENTRY(TexCoord1s) /* 100 "glTexCoord1s" */
2601 +ICD_ENTRY(TexCoord1sv) /* 101 "glTexCoord1sv" */
2602 +ICD_ENTRY(TexCoord2d) /* 102 "glTexCoord2d" */
2603 +ICD_ENTRY(TexCoord2dv) /* 103 "glTexCoord2dv" */
2604 +ICD_ENTRY(TexCoord2f) /* 104 "glTexCoord2f" */
2605 +ICD_ENTRY(TexCoord2fv) /* 105 "glTexCoord2fv" */
2606 +ICD_ENTRY(TexCoord2i) /* 106 "glTexCoord2i" */
2607 +ICD_ENTRY(TexCoord2iv) /* 107 "glTexCoord2iv" */
2608 +ICD_ENTRY(TexCoord2s) /* 108 "glTexCoord2s" */
2609 +ICD_ENTRY(TexCoord2sv) /* 109 "glTexCoord2sv" */
2610 +ICD_ENTRY(TexCoord3d) /* 110 "glTexCoord3d" */
2611 +ICD_ENTRY(TexCoord3dv) /* 111 "glTexCoord3dv" */
2612 +ICD_ENTRY(TexCoord3f) /* 112 "glTexCoord3f" */
2613 +ICD_ENTRY(TexCoord3fv) /* 113 "glTexCoord3fv" */
2614 +ICD_ENTRY(TexCoord3i) /* 114 "glTexCoord3i" */
2615 +ICD_ENTRY(TexCoord3iv) /* 115 "glTexCoord3iv" */
2616 +ICD_ENTRY(TexCoord3s) /* 116 "glTexCoord3s" */
2617 +ICD_ENTRY(TexCoord3sv) /* 117 "glTexCoord3sv" */
2618 +ICD_ENTRY(TexCoord4d) /* 118 "glTexCoord4d" */
2619 +ICD_ENTRY(TexCoord4dv) /* 119 "glTexCoord4dv" */
2620 +ICD_ENTRY(TexCoord4f) /* 120 "glTexCoord4f" */
2621 +ICD_ENTRY(TexCoord4fv) /* 121 "glTexCoord4fv" */
2622 +ICD_ENTRY(TexCoord4i) /* 122 "glTexCoord4i" */
2623 +ICD_ENTRY(TexCoord4iv) /* 123 "glTexCoord4iv" */
2624 +ICD_ENTRY(TexCoord4s) /* 124 "glTexCoord4s" */
2625 +ICD_ENTRY(TexCoord4sv) /* 125 "glTexCoord4sv" */
2626 +ICD_ENTRY(Vertex2d) /* 126 "glVertex2d" */
2627 +ICD_ENTRY(Vertex2dv) /* 127 "glVertex2dv" */
2628 +ICD_ENTRY(Vertex2f) /* 128 "glVertex2f" */
2629 +ICD_ENTRY(Vertex2fv) /* 129 "glVertex2fv" */
2630 +ICD_ENTRY(Vertex2i) /* 130 "glVertex2i" */
2631 +ICD_ENTRY(Vertex2iv) /* 131 "glVertex2iv" */
2632 +ICD_ENTRY(Vertex2s) /* 132 "glVertex2s" */
2633 +ICD_ENTRY(Vertex2sv) /* 133 "glVertex2sv" */
2634 +ICD_ENTRY(Vertex3d) /* 134 "glVertex3d" */
2635 +ICD_ENTRY(Vertex3dv) /* 135 "glVertex3dv" */
2636 +ICD_ENTRY(Vertex3f) /* 136 "glVertex3f" */
2637 +ICD_ENTRY(Vertex3fv) /* 137 "glVertex3fv" */
2638 +ICD_ENTRY(Vertex3i) /* 138 "glVertex3i" */
2639 +ICD_ENTRY(Vertex3iv) /* 139 "glVertex3iv" */
2640 +ICD_ENTRY(Vertex3s) /* 140 "glVertex3s" */
2641 +ICD_ENTRY(Vertex3sv) /* 141 "glVertex3sv" */
2642 +ICD_ENTRY(Vertex4d) /* 142 "glVertex4d" */
2643 +ICD_ENTRY(Vertex4dv) /* 143 "glVertex4dv" */
2644 +ICD_ENTRY(Vertex4f) /* 144 "glVertex4f" */
2645 +ICD_ENTRY(Vertex4fv) /* 145 "glVertex4fv" */
2646 +ICD_ENTRY(Vertex4i) /* 146 "glVertex4i" */
2647 +ICD_ENTRY(Vertex4iv) /* 147 "glVertex4iv" */
2648 +ICD_ENTRY(Vertex4s) /* 148 "glVertex4s" */
2649 +ICD_ENTRY(Vertex4sv) /* 149 "glVertex4sv" */
2650 +ICD_ENTRY(ClipPlane) /* 150 "glClipPlane" */
2651 +ICD_ENTRY(ColorMaterial) /* 151 "glColorMaterial" */
2652 +ICD_ENTRY(CullFace) /* 152 "glCullFace" */
2653 +ICD_ENTRY(Fogf) /* 153 "glFogf" */
2654 +ICD_ENTRY(Fogfv) /* 154 "glFogfv" */
2655 +ICD_ENTRY(Fogi) /* 155 "glFogi" */
2656 +ICD_ENTRY(Fogiv) /* 156 "glFogiv" */
2657 +ICD_ENTRY(FrontFace) /* 157 "glFrontFace" */
2658 +ICD_ENTRY(Hint) /* 158 "glHint" */
2659 +ICD_ENTRY(Lightf) /* 159 "glLightf" */
2660 +ICD_ENTRY(Lightfv) /* 160 "glLightfv" */
2661 +ICD_ENTRY(Lighti) /* 161 "glLighti" */
2662 +ICD_ENTRY(Lightiv) /* 162 "glLightiv" */
2663 +ICD_ENTRY(LightModelf) /* 163 "glLightModelf" */
2664 +ICD_ENTRY(LightModelfv) /* 164 "glLightModelfv" */
2665 +ICD_ENTRY(LightModeli) /* 165 "glLightModeli" */
2666 +ICD_ENTRY(LightModeliv) /* 166 "glLightModeliv" */
2667 +ICD_ENTRY(LineStipple) /* 167 "glLineStipple" */
2668 +ICD_ENTRY(LineWidth) /* 168 "glLineWidth" */
2669 +ICD_ENTRY(Materialf) /* 169 "glMaterialf" */
2670 +ICD_ENTRY(Materialfv) /* 170 "glMaterialfv" */
2671 +ICD_ENTRY(Materiali) /* 171 "glMateriali" */
2672 +ICD_ENTRY(Materialiv) /* 172 "glMaterialiv" */
2673 +ICD_ENTRY(PointSize) /* 173 "glPointSize" */
2674 +ICD_ENTRY(PolygonMode) /* 174 "glPolygonMode" */
2675 +ICD_ENTRY(PolygonStipple) /* 175 "glPolygonStipple" */
2676 +ICD_ENTRY(Scissor) /* 176 "glScissor" */
2677 +ICD_ENTRY(ShadeModel) /* 177 "glShadeModel" */
2678 +ICD_ENTRY(TexParameterf) /* 178 "glTexParameterf" */
2679 +ICD_ENTRY(TexParameterfv) /* 179 "glTexParameterfv" */
2680 +ICD_ENTRY(TexParameteri) /* 180 "glTexParameteri" */
2681 +ICD_ENTRY(TexParameteriv) /* 181 "glTexParameteriv" */
2682 +ICD_ENTRY(TexImage1D) /* 182 "glTexImage1D" */
2683 +ICD_ENTRY(TexImage2D) /* 183 "glTexImage2D" */
2684 +ICD_ENTRY(TexEnvf) /* 184 "glTexEnvf" */
2685 +ICD_ENTRY(TexEnvfv) /* 185 "glTexEnvfv" */
2686 +ICD_ENTRY(TexEnvi) /* 186 "glTexEnvi" */
2687 +ICD_ENTRY(TexEnviv) /* 187 "glTexEnviv" */
2688 +ICD_ENTRY(TexGend) /* 188 "glTexGend" */
2689 +ICD_ENTRY(TexGendv) /* 189 "glTexGendv" */
2690 +ICD_ENTRY(TexGenf) /* 190 "glTexGenf" */
2691 +ICD_ENTRY(TexGenfv) /* 191 "glTexGenfv" */
2692 +ICD_ENTRY(TexGeni) /* 192 "glTexGeni" */
2693 +ICD_ENTRY(TexGeniv) /* 193 "glTexGeniv" */
2694 +ICD_ENTRY(FeedbackBuffer) /* 194 "glFeedbackBuffer" */
2695 +ICD_ENTRY(SelectBuffer) /* 195 "glSelectBuffer" */
2696 +ICD_ENTRY(RenderMode) /* 196 "glRenderMode" */
2697 +ICD_ENTRY(InitNames) /* 197 "glInitNames" */
2698 +ICD_ENTRY(LoadName) /* 198 "glLoadName" */
2699 +ICD_ENTRY(PassThrough) /* 199 "glPassThrough" */
2700 +ICD_ENTRY(PopName) /* 200 "glPopName" */
2701 +ICD_ENTRY(PushName) /* 201 "glPushName" */
2702 +ICD_ENTRY(DrawBuffer) /* 202 glDrawBuffer" */
2703 +ICD_ENTRY(Clear) /* 203 "glClear" */
2704 +ICD_ENTRY(ClearAccum) /* 204 "glClearAccum" */
2705 +ICD_ENTRY(ClearIndex) /* 205 "glClearIndex" */
2706 +ICD_ENTRY(ClearColor) /* 206 "glClearColor" */
2707 +ICD_ENTRY(ClearStencil) /* 207 "glClearStencil" */
2708 +ICD_ENTRY(ClearDepth) /* 208 "glClearDepth" */
2709 +ICD_ENTRY(StencilMask) /* 209 "glStencilMask" */
2710 +ICD_ENTRY(ColorMask) /* 210 "glColorMask" */
2711 +ICD_ENTRY(DepthMask) /* 211 "glDepthMask" */
2712 +ICD_ENTRY(IndexMask) /* 212 "glIndexMask" */
2713 +ICD_ENTRY(Accum) /* 213 "glAccum" */
2714 +ICD_ENTRY(Disable) /* 214 "glDisable" */
2715 +ICD_ENTRY(Enable) /* 215 "glEnable" */
2716 +ICD_ENTRY(Finish) /* 216 "glFinish" */
2717 +ICD_ENTRY(Flush) /* 217 "glFlush" */
2718 +ICD_ENTRY(PopAttrib) /* 218 "glPopAttrib" */
2719 +ICD_ENTRY(PushAttrib) /* 219 "glPushAttrib" */
2720 +ICD_ENTRY(Map1d) /* 220 "glMap1d" */
2721 +ICD_ENTRY(Map1f) /* 221 "glMap1f" */
2722 +ICD_ENTRY(Map2d) /* 222 "glMap2d" */
2723 +ICD_ENTRY(Map2f) /* 223 "glMap2f" */
2724 +ICD_ENTRY(MapGrid1d) /* 224 "glMapGrid1d" */
2725 +ICD_ENTRY(MapGrid1f) /* 225 "glMapGrid1f" */
2726 +ICD_ENTRY(MapGrid2d) /* 226 "glMapGrid2d" */
2727 +ICD_ENTRY(MapGrid2f) /* 227 "glMapGrid2f" */
2728 +ICD_ENTRY(EvalCoord1d) /* 228 "glEvalCoord1d" */
2729 +ICD_ENTRY(EvalCoord1dv) /* 229 "glEvalCoord1dv" */
2730 +ICD_ENTRY(EvalCoord1f) /* 230 "glEvalCoord1f" */
2731 +ICD_ENTRY(EvalCoord1fv) /* 231 "glEvalCoord1fv" */
2732 +ICD_ENTRY(EvalCoord2d) /* 232 "glEvalCoord2d" */
2733 +ICD_ENTRY(EvalCoord2dv) /* 233 "glEvalCoord2dv" */
2734 +ICD_ENTRY(EvalCoord2f) /* 234 "glEvalCoord2f" */
2735 +ICD_ENTRY(EvalCoord2fv) /* 235 "glEvalCoord2fv" */
2736 +ICD_ENTRY(EvalMesh1) /* 236 "glEvalMesh1" */
2737 +ICD_ENTRY(EvalPoint1) /* 237 "glEvalPoint1" */
2738 +ICD_ENTRY(EvalMesh2) /* 238 "glEvalMesh2" */
2739 +ICD_ENTRY(EvalPoint2) /* 239 "glEvalPoint2" */
2740 +ICD_ENTRY(AlphaFunc) /* 240 "glAlphaFunc" */
2741 +ICD_ENTRY(BlendFunc) /* 241 "glBlendFunc" */
2742 +ICD_ENTRY(LogicOp) /* 242 "glLogicOp" */
2743 +ICD_ENTRY(StencilFunc) /* 243 "glStencilFunc" */
2744 +ICD_ENTRY(StencilOp) /* 244 "glStencilOp" */
2745 +ICD_ENTRY(DepthFunc) /* 245 "glDepthFunc" */
2746 +ICD_ENTRY(PixelZoom) /* 246 "glPixelZoom" */
2747 +ICD_ENTRY(PixelTransferf) /* 247 "glPixelTransferf" */
2748 +ICD_ENTRY(PixelTransferi) /* 248 "glPixelTransferi" */
2749 +ICD_ENTRY(PixelStoref) /* 249 "glPixelStoref" */
2750 +ICD_ENTRY(PixelStorei) /* 250 "glPixelStorei" */
2751 +ICD_ENTRY(PixelMapfv) /* 251 "glPixelMapfv" */
2752 +ICD_ENTRY(PixelMapuiv) /* 252 "glPixelMapuiv" */
2753 +ICD_ENTRY(PixelMapusv) /* 253 "glPixelMapusv" */
2754 +ICD_ENTRY(ReadBuffer) /* 254 "glReadBuffer" */
2755 +ICD_ENTRY(CopyPixels) /* 255 "glCopyPixels" */
2756 +ICD_ENTRY(ReadPixels) /* 256 "glReadPixels" */
2757 +ICD_ENTRY(DrawPixels) /* 257 "glDrawPixels" */
2758 +ICD_ENTRY(GetBooleanv) /* 258 "glGetBooleanv" */
2759 +ICD_ENTRY(GetClipPlane) /* 259 "glGetClipPlane" */
2760 +ICD_ENTRY(GetDoublev) /* 260 "glGetDoublev" */
2761 +ICD_ENTRY(GetError) /* 261 "glGetError" */
2762 +ICD_ENTRY(GetFloatv) /* 262 "glGetFloatv" */
2763 +ICD_ENTRY(GetIntegerv) /* 263 "glGetIntegerv" */
2764 +ICD_ENTRY(GetLightfv) /* 264 "glGetLightfv" */
2765 +ICD_ENTRY(GetLightiv) /* 265 "glGetLightiv" */
2766 +ICD_ENTRY(GetMapdv) /* 266 "glGetMapdv" */
2767 +ICD_ENTRY(GetMapfv) /* 267 "glGetMapfv" */
2768 +ICD_ENTRY(GetMapiv) /* 268 "glGetMapiv" */
2769 +ICD_ENTRY(GetMaterialfv) /* 269 "glGetMaterialfv" */
2770 +ICD_ENTRY(GetMaterialiv) /* 270 "glGetMaterialiv" */
2771 +ICD_ENTRY(GetPixelMapfv) /* 271 "glGetPixelMapfv" */
2772 +ICD_ENTRY(GetPixelMapuiv) /* 272 "glGetPixelMapuiv" */
2773 +ICD_ENTRY(GetPixelMapusv) /* 273 "glGetPixelMapusv" */
2774 +ICD_ENTRY(GetPolygonStipple) /* 274 "glGetPolygonStipple" */
2775 +ICD_ENTRY(GetString) /* 275 "glGetString" */
2776 +ICD_ENTRY(GetTexEnvfv) /* 276 "glGetTexEnvfv" */
2777 +ICD_ENTRY(GetTexEnviv) /* 277 "glGetTexEnviv" */
2778 +ICD_ENTRY(GetTexGendv) /* 278 "glGetTexGendv" */
2779 +ICD_ENTRY(GetTexGenfv) /* 279 "glGetTexGenfv" */
2780 +ICD_ENTRY(GetTexGeniv) /* 280 "glGetTexGeniv" */
2781 +ICD_ENTRY(GetTexImage) /* 281 "glGetTexImage" */
2782 +ICD_ENTRY(GetTexParameterfv) /* 282 "glGetTexParameterfv" */
2783 +ICD_ENTRY(GetTexParameteriv) /* 283 "glGetTexParameteriv" */
2784 +ICD_ENTRY(GetTexLevelParameterfv) /* 284 "glGetTexLevelParameterfv" */
2785 +ICD_ENTRY(GetTexLevelParameteriv) /* 285 "glGetTexLevelParameteriv" */
2786 +ICD_ENTRY(IsEnabled) /* 286 "glIsEnabled" */
2787 +ICD_ENTRY(IsList) /* 287 "glIsList" */
2788 +ICD_ENTRY(DepthRange) /* 288 "glDepthRange" */
2789 +ICD_ENTRY(Frustum) /* 289 "glFrustum" */
2790 +ICD_ENTRY(LoadIdentity) /* 290 "glLoadIdentity" */
2791 +ICD_ENTRY(LoadMatrixf) /* 291 "glLoadMatrixf" */
2792 +ICD_ENTRY(LoadMatrixd) /* 292 "glLoadMatrixd" */
2793 +ICD_ENTRY(MatrixMode) /* 293 "glMatrixMode" */
2794 +ICD_ENTRY(MultMatrixf) /* 294 "glMultMatrixf" */
2795 +ICD_ENTRY(MultMatrixd) /* 295 "glMultMatrixd" */
2796 +ICD_ENTRY(Ortho) /* 296 "glOrtho" */
2797 +ICD_ENTRY(PopMatrix) /* 297 "glPopMatrix" */
2798 +ICD_ENTRY(PushMatrix) /* 298 "glPushMatrix" */
2799 +ICD_ENTRY(Rotated) /* 299 "glRotated" */
2800 +ICD_ENTRY(Rotatef) /* 300 "glRotatef" */
2801 +ICD_ENTRY(Scaled) /* 301 "glScaled" */
2802 +ICD_ENTRY(Scalef) /* 302 "glScalef" */
2803 +ICD_ENTRY(Translated) /* 303 "glTranslated" */
2804 +ICD_ENTRY(Translatef) /* 304 "glTranslatef" */
2805 +ICD_ENTRY(Viewport) /* 305 "glViewport" */
2806 +/* OpenGL version 1.1 */
2807 +ICD_ENTRY(ArrayElement) /* 306 "glArrayElement" */
2808 +ICD_ENTRY(BindTexture) /* 307 "glBindTexture" */
2809 +ICD_ENTRY(ColorPointer) /* 308 "glColorPointer" */
2810 +ICD_ENTRY(DisableClientState) /* 309 "glDisableClientState" */
2811 +ICD_ENTRY(DrawArrays) /* 310 "glDrawArrays" */
2812 +ICD_ENTRY(DrawElements) /* 311 "glDrawElements" */
2813 +ICD_ENTRY(EdgeFlagPointer) /* 312 "glEdgeFlagPointer" */
2814 +ICD_ENTRY(EnableClientState) /* 313 "glEnableClientState" */
2815 +ICD_ENTRY(IndexPointer) /* 314 "glIndexPointer" */
2816 +ICD_ENTRY(Indexub) /* 315 "glIndexub" */
2817 +ICD_ENTRY(Indexubv) /* 316 "glIndexubv" */
2818 +ICD_ENTRY(InterleavedArrays) /* 317 "glInterleavedArrays" */
2819 +ICD_ENTRY(NormalPointer) /* 318 "glNormalPointer" */
2820 +ICD_ENTRY(PolygonOffset) /* 319 "glPolygonOffset" */
2821 +ICD_ENTRY(TexCoordPointer) /* 320 "glTexCoordPointer" */
2822 +ICD_ENTRY(VertexPointer) /* 321 "glVertexPointer" */
2823 +ICD_ENTRY(AreTexturesResident) /* 322 "glAreTexturesResident" */
2824 +ICD_ENTRY(CopyTexImage1D) /* 323 "glCopyTexImage1D" */
2825 +ICD_ENTRY(CopyTexImage2D) /* 324 "glCopyTexImage2D" */
2826 +ICD_ENTRY(CopyTexSubImage1D) /* 325 "glCopyTexSubImage1D" */
2827 +ICD_ENTRY(CopyTexSubImage2D) /* 326 "glCopyTexSubImage2D" */
2828 +ICD_ENTRY(DeleteTextures) /* 327 "glDeleteTextures" */
2829 +ICD_ENTRY(GenTextures) /* 328 "glGenTextures" */
2830 +ICD_ENTRY(GetPointerv) /* 329 "glGetPointerv" */
2831 +ICD_ENTRY(IsTexture) /* 330 "glIsTexture" */
2832 +ICD_ENTRY(PrioritizeTextures) /* 331 "glPrioritizeTextures" */
2833 +ICD_ENTRY(TexSubImage1D) /* 332 "glTexSubImage1D" */
2834 +ICD_ENTRY(TexSubImage2D) /* 333 "glTexSubImage2D" */
2835 +ICD_ENTRY(PopClientAttrib) /* 334 "glPopClientAttrib" */
2836 +ICD_ENTRY(PushClientAttrib) /* 335 "glPushClientAttrib" */
2837 +/* OpenGL 1.2 and 1.2.1 */
2838 +ICD_ENTRY(TexImage3D) /* 336 "glTexImage3D" */
2839 +ICD_ENTRY(TexSubImage3D) /* 337 "glTexSubImage3D" */
2840 +ICD_ENTRY(DrawRangeElements) /* 338 "glDrawRangeElements" */
2841 +ICD_ENTRY(BlendColor) /* 339 "glBlendColor" */
2842 +ICD_ENTRY(BlendEquation) /* 340 "glBlendEquation" */
2843 +/* Open 1.3 */
2844 +ICD_ENTRY(ActiveTexture) /* 341 "glActiveTexture" */
2845 +ICD_ENTRY(ClientActiveTexture) /* 342 "glClientActiveTexture" */
2846 +ICD_ENTRY(MultiTexCoord1d) /* 343 "glMultiTexCoord1d" */
2847 +ICD_ENTRY(MultiTexCoord1dv) /* 344 "glMultiTexCoord1dv" */
2848 +ICD_ENTRY(MultiTexCoord1f) /* 345 "glMultiTexCoord1f" */
2849 +ICD_ENTRY(MultiTexCoord1f) /* 346 "glMultiTexCoord1fv" */
2850 +ICD_ENTRY(MultiTexCoord1i) /* 347 "glMultiTexCoord1i" */
2851 +ICD_ENTRY(MultiTexCoord1iv) /* 348 "glMultiTexCoord1iv" */
2852 +ICD_ENTRY(MultiTexCoord1s) /* 349 "glMultiTexCoord1s" */
2853 +ICD_ENTRY(MultiTexCoord1sv) /* 350 "glMultiTexCoord1sv" */
2854 +ICD_ENTRY(MultiTexCoord2d) /* 351 "glMultiTexCoord2d" */
2855 +ICD_ENTRY(MultiTexCoord2dv) /* 352 "glMultiTexCoord2dv" */
2856 +ICD_ENTRY(MultiTexCoord2f) /* 353 "glMultiTexCoord2f" */
2857 +ICD_ENTRY(MultiTexCoord2fv) /* 354 "glMultiTexCoord2fv" */
2858 +ICD_ENTRY(MultiTexCoord2i) /* 355 "glMultiTexCoord2i" */
2859 +ICD_ENTRY(MultiTexCoord2iv) /* 356 "glMultiTexCoord2iv" */
2860 +ICD_ENTRY(MultiTexCoord2s) /* 357 "glMultiTexCoord2s" */
2861 +ICD_ENTRY(MultiTexCoord2sv) /* 358 "glMultiTexCoord2sv" */
2862 +ICD_ENTRY(MultiTexCoord3d) /* 359 "glMultiTexCoord3d" */
2863 +ICD_ENTRY(MultiTexCoord3dv) /* 360 "glMultiTexCoord3dv" */
2864 +ICD_ENTRY(MultiTexCoord3f) /* 361 "glMultiTexCoord3f" */
2865 +ICD_ENTRY(MultiTexCoord3fv) /* 362 "glMultiTexCoord3fv" */
2866 +ICD_ENTRY(MultiTexCoord3i) /* 363 "glMultiTexCoord3i" */
2867 +ICD_ENTRY(MultiTexCoord3iv) /* 364 "glMultiTexCoord3iv" */
2868 +ICD_ENTRY(MultiTexCoord3s) /* 365 "glMultiTexCoord3s" */
2869 +ICD_ENTRY(MultiTexCoord3sv) /* 366 "glMultiTexCoord3sv" */
2870 +ICD_ENTRY(MultiTexCoord4d) /* 367 "glMultiTexCoord4d" */
2871 +ICD_ENTRY(MultiTexCoord4dv) /* 368 "glMultiTexCoord4dv" */
2872 +ICD_ENTRY(MultiTexCoord4f) /* 369 "glMultiTexCoord4f" */
2873 +ICD_ENTRY(MultiTexCoord4fv) /* 370 "glMultiTexCoord4fv" */
2874 +ICD_ENTRY(MultiTexCoord4i) /* 371 "glMultiTexCoord4i" */
2875 +ICD_ENTRY(MultiTexCoord4iv) /* 372 "glMultiTexCoord4iv" */
2876 +ICD_ENTRY(MultiTexCoord4s) /* 373 "glMultiTexCoord4s" */
2877 +ICD_ENTRY(MultiTexCoord4sv) /* 374 "glMultiTexCoord4sv" */
2878 +ICD_ENTRY(LoadTransposeMatrixf) /* 375 "glLoadTransposeMatrixf" */
2879 +ICD_ENTRY(LoadTransposeMatrixd) /* 376 "glLoadTransposeMatrixd" */
2880 +ICD_ENTRY(MultTransposeMatrixf) /* 377 "glMultTransposeMatrixf" */
2881 +ICD_ENTRY(MultTransposeMatrixd) /* 378 "glMultTransposeMatrixd" */
2882 +ICD_ENTRY(CompressedTexImage3D) /* 379 "glCompressedTexImage3D" */
2883 +ICD_ENTRY(CompressedTexImage2D) /* 380 "glCompressedTexImage2D" */
2884 +ICD_ENTRY(CompressedTexImage1D) /* 381 "glCompressedTexImage1D" */
2885 +ICD_ENTRY(CompressedTexSubImage3D) /* 382 "glCompressedTexSubImage3D" */
2886 +ICD_ENTRY(CompressedTexSubImage2D) /* 383 "glCompressedTexSubImage2D" */
2887 +ICD_ENTRY(CompressedTexSubImage1D) /* 384 "glCompressedTexSubImage1D" */
2888 +ICD_ENTRY(GetCompressedTexImage) /* 385 "glGetCompressedTexImage" */
2889 +ICD_ENTRY(SampleCoverage) /* 386 "glSampleCoverage" */
2890 +/* Open 1.4 and higher */
2891 +ICD_ENTRY(FogCoordf) /* 387 "glFogCoordf" */
2892 +ICD_ENTRY(FogCoordd) /* 388 "glFogCoordd" */
2893 +ICD_ENTRY(FogCoordfv) /* 389 "glFogCoordfv" */
2894 +ICD_ENTRY(FogCoorddv) /* 390 "glFogCoorddv" */
2895 +ICD_ENTRY(FogCoordPointer) /* 391 "glFogCoordPointer" */
2896 +ICD_ENTRY(SecondaryColor3b) /* 392 "glSecondaryColor3b" */
2897 +ICD_ENTRY(SecondaryColor3bv) /* 393 "glSecondaryColor3bv" */
2898 +ICD_ENTRY(SecondaryColor3d) /* 394 "glSecondaryColor3d" */
2899 +ICD_ENTRY(SecondaryColor3dv) /* 395 "glSecondaryColor3dv" */
2900 +ICD_ENTRY(SecondaryColor3f) /* 396 "glSecondaryColor3f" */
2901 +ICD_ENTRY(SecondaryColor3fv) /* 397 "glSecondaryColor3fv" */
2902 +ICD_ENTRY(SecondaryColor3i) /* 398 "glSecondaryColor3i" */
2903 +ICD_ENTRY(SecondaryColor3iv) /* 399 "glSecondaryColor3iv" */
2904 +ICD_ENTRY(SecondaryColor3s) /* 400 "glSecondaryColor3s" */
2905 +ICD_ENTRY(SecondaryColor3sv) /* 401 "glSecondaryColor3sv" */
2906 +ICD_ENTRY(SecondaryColor3ub) /* 402 "glSecondaryColor3ub" */
2907 +ICD_ENTRY(SecondaryColor3ubv) /* 403 "glSecondaryColor3ubv" */
2908 +ICD_ENTRY(SecondaryColor3ui) /* 404 "glSecondaryColor3ui" */
2909 +ICD_ENTRY(SecondaryColor3uiv) /* 405 "glSecondaryColor3uiv" */
2910 +ICD_ENTRY(SecondaryColor3us) /* 406 "glSecondaryColor3us" */
2911 +ICD_ENTRY(SecondaryColor3usv) /* 407 "glSecondaryColor3usv" */
2912 +ICD_ENTRY(SecondaryColorPointer) /* 408 "glSecondaryColorPointer" */
2913 +ICD_ENTRY(MultiDrawArrays) /* 409 "glMultiDrawArrays" */
2914 +ICD_ENTRY(MultiDrawElements) /* 410 "glMultiDrawElements" */
2915 +ICD_ENTRY(PointParameterf) /* 411 "glPointParameterf" */
2916 +ICD_ENTRY(PointParameterfv) /* 412 "glPointParameterfv" */
2917 +ICD_ENTRY(PointParameteri) /* 413 "glPointParameteri" */
2918 +ICD_ENTRY(PointParameteriv) /* 414 "glPointParameteriv" */
2919 +ICD_ENTRY(BlendFuncSeparate) /* 415 "glBlendFuncSeparate" */
2920 +ICD_ENTRY(WindowPos2d) /* 416 "glWindowPos2d" */
2921 +ICD_ENTRY(WindowPos2dv) /* 417 "glWindowPos2dv" */
2922 +
2923 Index: drivers/windows/icd/mesa.def
2924 ===================================================================
2925 --- drivers/windows/icd/mesa.def (revision 7)
2926 +++ drivers/windows/icd/mesa.def (working copy)
2927 @@ -1,108 +1,949 @@
2928 -DESCRIPTION 'Mesa (OpenGL driver) for Win32'
2929 -VERSION 6.1
2930 -
2931 -EXPORTS
2932 -;
2933 -; ICD API
2934 - DrvCopyContext
2935 - DrvCreateContext
2936 - DrvCreateLayerContext
2937 - DrvDeleteContext
2938 - DrvDescribeLayerPlane
2939 - DrvDescribePixelFormat
2940 - DrvGetLayerPaletteEntries
2941 - DrvGetProcAddress
2942 - DrvReleaseContext
2943 - DrvRealizeLayerPalette
2944 - DrvSetContext
2945 - DrvSetLayerPaletteEntries
2946 - DrvSetPixelFormat
2947 - DrvShareLists
2948 - DrvSwapBuffers
2949 - DrvSwapLayerBuffers
2950 - DrvValidateVersion
2951 -
2952 -;
2953 -; Mesa internals - mostly for OSMESA
2954 - _vbo_CreateContext
2955 - _vbo_DestroyContext
2956 - _vbo_InvalidateState
2957 - _glapi_get_context
2958 - _glapi_get_proc_address
2959 - _mesa_buffer_data
2960 - _mesa_buffer_map
2961 - _mesa_buffer_subdata
2962 - _mesa_bzero
2963 - _mesa_calloc
2964 - _mesa_choose_tex_format
2965 - _mesa_compressed_texture_size
2966 - _mesa_create_framebuffer
2967 - _mesa_create_visual
2968 - _mesa_delete_buffer_object
2969 - _mesa_delete_texture_object
2970 - _mesa_destroy_framebuffer
2971 - _mesa_destroy_visual
2972 - _mesa_enable_1_3_extensions
2973 - _mesa_enable_1_4_extensions
2974 - _mesa_enable_1_5_extensions
2975 - _mesa_enable_sw_extensions
2976 - _mesa_error
2977 - _mesa_free
2978 - _mesa_free_context_data
2979 - _mesa_get_current_context
2980 - _mesa_init_default_imports
2981 - _mesa_init_driver_functions
2982 - _mesa_initialize_context
2983 - _mesa_make_current
2984 - _mesa_memcpy
2985 - _mesa_memset
2986 - _mesa_new_buffer_object
2987 - _mesa_new_texture_object
2988 - _mesa_problem
2989 - _mesa_ResizeBuffersMESA
2990 - _mesa_store_compressed_teximage1d
2991 - _mesa_store_compressed_teximage2d
2992 - _mesa_store_compressed_teximage3d
2993 - _mesa_store_compressed_texsubimage1d
2994 - _mesa_store_compressed_texsubimage2d
2995 - _mesa_store_compressed_texsubimage3d
2996 - _mesa_store_teximage1d
2997 - _mesa_store_teximage2d
2998 - _mesa_store_teximage3d
2999 - _mesa_store_texsubimage1d
3000 - _mesa_store_texsubimage2d
3001 - _mesa_store_texsubimage3d
3002 - _mesa_strcmp
3003 - _mesa_test_proxy_teximage
3004 - _mesa_Viewport
3005 - _swrast_Accum
3006 - _swrast_Bitmap
3007 - _swrast_CopyPixels
3008 - _swrast_DrawBuffer
3009 - _swrast_DrawPixels
3010 - _swrast_GetDeviceDriverReference
3011 - _swrast_Clear
3012 - _swrast_choose_line
3013 - _swrast_choose_triangle
3014 - _swrast_CopyColorSubTable
3015 - _swrast_CopyColorTable
3016 - _swrast_CopyConvolutionFilter1D
3017 - _swrast_CopyConvolutionFilter2D
3018 - _swrast_copy_teximage1d
3019 - _swrast_copy_teximage2d
3020 - _swrast_copy_texsubimage1d
3021 - _swrast_copy_texsubimage2d
3022 - _swrast_copy_texsubimage3d
3023 - _swrast_CreateContext
3024 - _swrast_DestroyContext
3025 - _swrast_InvalidateState
3026 - _swrast_ReadPixels
3027 - _swsetup_Wakeup
3028 - _swsetup_CreateContext
3029 - _swsetup_DestroyContext
3030 - _swsetup_InvalidateState
3031 - _tnl_CreateContext
3032 - _tnl_DestroyContext
3033 - _tnl_InvalidateState
3034 - _tnl_MakeCurrent
3035 - _tnl_run_pipeline
3036 +DESCRIPTION 'Mesa (OpenGL driver) for Win32'
3037 +VERSION 7.3
3038 +
3039 +EXPORTS
3040 +;
3041 +; ICD API
3042 + DrvCopyContext
3043 + DrvCreateContext
3044 + DrvCreateLayerContext
3045 + DrvDeleteContext
3046 + DrvDescribeLayerPlane
3047 + DrvDescribePixelFormat
3048 + DrvGetLayerPaletteEntries
3049 + DrvGetProcAddress
3050 + DrvReleaseContext
3051 + DrvRealizeLayerPalette
3052 + DrvSetContext
3053 + DrvSetLayerPaletteEntries
3054 + DrvSetPixelFormat
3055 + DrvShareLists
3056 + DrvSwapBuffers
3057 + DrvSwapLayerBuffers
3058 + DrvValidateVersion
3059 +
3060 +; Standalon
3061 + glNewList
3062 + glEndList
3063 + glCallList
3064 + glCallLists
3065 + glDeleteLists
3066 + glGenLists
3067 + glListBase
3068 + glBegin
3069 + glBitmap
3070 + glColor3b
3071 + glColor3bv
3072 + glColor3d
3073 + glColor3dv
3074 + glColor3f
3075 + glColor3fv
3076 + glColor3i
3077 + glColor3iv
3078 + glColor3s
3079 + glColor3sv
3080 + glColor3ub
3081 + glColor3ubv
3082 + glColor3ui
3083 + glColor3uiv
3084 + glColor3us
3085 + glColor3usv
3086 + glColor4b
3087 + glColor4bv
3088 + glColor4d
3089 + glColor4dv
3090 + glColor4f
3091 + glColor4fv
3092 + glColor4i
3093 + glColor4iv
3094 + glColor4s
3095 + glColor4sv
3096 + glColor4ub
3097 + glColor4ubv
3098 + glColor4ui
3099 + glColor4uiv
3100 + glColor4us
3101 + glColor4usv
3102 + glEdgeFlag
3103 + glEdgeFlagv
3104 + glEnd
3105 + glIndexd
3106 + glIndexdv
3107 + glIndexf
3108 + glIndexfv
3109 + glIndexi
3110 + glIndexiv
3111 + glIndexs
3112 + glIndexsv
3113 + glNormal3b
3114 + glNormal3bv
3115 + glNormal3d
3116 + glNormal3dv
3117 + glNormal3f
3118 + glNormal3fv
3119 + glNormal3i
3120 + glNormal3iv
3121 + glNormal3s
3122 + glNormal3sv
3123 + glRasterPos2d
3124 + glRasterPos2dv
3125 + glRasterPos2f
3126 + glRasterPos2fv
3127 + glRasterPos2i
3128 + glRasterPos2iv
3129 + glRasterPos2s
3130 + glRasterPos2sv
3131 + glRasterPos3d
3132 + glRasterPos3dv
3133 + glRasterPos3f
3134 + glRasterPos3fv
3135 + glRasterPos3i
3136 + glRasterPos3iv
3137 + glRasterPos3s
3138 + glRasterPos3sv
3139 + glRasterPos4d
3140 + glRasterPos4dv
3141 + glRasterPos4f
3142 + glRasterPos4fv
3143 + glRasterPos4i
3144 + glRasterPos4iv
3145 + glRasterPos4s
3146 + glRasterPos4sv
3147 + glRectd
3148 + glRectdv
3149 + glRectf
3150 + glRectfv
3151 + glRecti
3152 + glRectiv
3153 + glRects
3154 + glRectsv
3155 + glTexCoord1d
3156 + glTexCoord1dv
3157 + glTexCoord1f
3158 + glTexCoord1fv
3159 + glTexCoord1i
3160 + glTexCoord1iv
3161 + glTexCoord1s
3162 + glTexCoord1sv
3163 + glTexCoord2d
3164 + glTexCoord2dv
3165 + glTexCoord2f
3166 + glTexCoord2fv
3167 + glTexCoord2i
3168 + glTexCoord2iv
3169 + glTexCoord2s
3170 + glTexCoord2sv
3171 + glTexCoord3d
3172 + glTexCoord3dv
3173 + glTexCoord3f
3174 + glTexCoord3fv
3175 + glTexCoord3i
3176 + glTexCoord3iv
3177 + glTexCoord3s
3178 + glTexCoord3sv
3179 + glTexCoord4d
3180 + glTexCoord4dv
3181 + glTexCoord4f
3182 + glTexCoord4fv
3183 + glTexCoord4i
3184 + glTexCoord4iv
3185 + glTexCoord4s
3186 + glTexCoord4sv
3187 + glVertex2d
3188 + glVertex2dv
3189 + glVertex2f
3190 + glVertex2fv
3191 + glVertex2i
3192 + glVertex2iv
3193 + glVertex2s
3194 + glVertex2sv
3195 + glVertex3d
3196 + glVertex3dv
3197 + glVertex3f
3198 + glVertex3fv
3199 + glVertex3i
3200 + glVertex3iv
3201 + glVertex3s
3202 + glVertex3sv
3203 + glVertex4d
3204 + glVertex4dv
3205 + glVertex4f
3206 + glVertex4fv
3207 + glVertex4i
3208 + glVertex4iv
3209 + glVertex4s
3210 + glVertex4sv
3211 + glClipPlane
3212 + glColorMaterial
3213 + glCullFace
3214 + glFogf
3215 + glFogfv
3216 + glFogi
3217 + glFogiv
3218 + glFrontFace
3219 + glHint
3220 + glLightf
3221 + glLightfv
3222 + glLighti
3223 + glLightiv
3224 + glLightModelf
3225 + glLightModelfv
3226 + glLightModeli
3227 + glLightModeliv
3228 + glLineStipple
3229 + glLineWidth
3230 + glMaterialf
3231 + glMaterialfv
3232 + glMateriali
3233 + glMaterialiv
3234 + glPointSize
3235 + glPolygonMode
3236 + glPolygonStipple
3237 + glScissor
3238 + glShadeModel
3239 + glTexParameterf
3240 + glTexParameterfv
3241 + glTexParameteri
3242 + glTexParameteriv
3243 + glTexImage1D
3244 + glTexImage2D
3245 + glTexEnvf
3246 + glTexEnvfv
3247 + glTexEnvi
3248 + glTexEnviv
3249 + glTexGend
3250 + glTexGendv
3251 + glTexGenf
3252 + glTexGenfv
3253 + glTexGeni
3254 + glTexGeniv
3255 + glFeedbackBuffer
3256 + glSelectBuffer
3257 + glRenderMode
3258 + glInitNames
3259 + glLoadName
3260 + glPassThrough
3261 + glPopName
3262 + glPushName
3263 + glDrawBuffer
3264 + glClear
3265 + glClearAccum
3266 + glClearIndex
3267 + glClearColor
3268 + glClearStencil
3269 + glClearDepth
3270 + glStencilMask
3271 + glColorMask
3272 + glDepthMask
3273 + glIndexMask
3274 + glAccum
3275 + glDisable
3276 + glEnable
3277 + glFinish
3278 + glFlush
3279 + glPopAttrib
3280 + glPushAttrib
3281 + glMap1d
3282 + glMap1f
3283 + glMap2d
3284 + glMap2f
3285 + glMapGrid1d
3286 + glMapGrid1f
3287 + glMapGrid2d
3288 + glMapGrid2f
3289 + glEvalCoord1d
3290 + glEvalCoord1dv
3291 + glEvalCoord1f
3292 + glEvalCoord1fv
3293 + glEvalCoord2d
3294 + glEvalCoord2dv
3295 + glEvalCoord2f
3296 + glEvalCoord2fv
3297 + glEvalMesh1
3298 + glEvalPoint1
3299 + glEvalMesh2
3300 + glEvalPoint2
3301 + glAlphaFunc
3302 + glBlendFunc
3303 + glLogicOp
3304 + glStencilFunc
3305 + glStencilOp
3306 + glDepthFunc
3307 + glPixelZoom
3308 + glPixelTransferf
3309 + glPixelTransferi
3310 + glPixelStoref
3311 + glPixelStorei
3312 + glPixelMapfv
3313 + glPixelMapuiv
3314 + glPixelMapusv
3315 + glReadBuffer
3316 + glCopyPixels
3317 + glReadPixels
3318 + glDrawPixels
3319 + glGetBooleanv
3320 + glGetClipPlane
3321 + glGetDoublev
3322 + glGetError
3323 + glGetFloatv
3324 + glGetIntegerv
3325 + glGetLightfv
3326 + glGetLightiv
3327 + glGetMapdv
3328 + glGetMapfv
3329 + glGetMapiv
3330 + glGetMaterialfv
3331 + glGetMaterialiv
3332 + glGetPixelMapfv
3333 + glGetPixelMapuiv
3334 + glGetPixelMapusv
3335 + glGetPolygonStipple
3336 + glGetString
3337 + glGetTexEnvfv
3338 + glGetTexEnviv
3339 + glGetTexGendv
3340 + glGetTexGenfv
3341 + glGetTexGeniv
3342 + glGetTexImage
3343 + glGetTexParameterfv
3344 + glGetTexParameteriv
3345 + glGetTexLevelParameterfv
3346 + glGetTexLevelParameteriv
3347 + glIsEnabled
3348 + glIsList
3349 + glDepthRange
3350 + glFrustum
3351 + glLoadIdentity
3352 + glLoadMatrixf
3353 + glLoadMatrixd
3354 + glMatrixMode
3355 + glMultMatrixf
3356 + glMultMatrixd
3357 + glOrtho
3358 + glPopMatrix
3359 + glPushMatrix
3360 + glRotated
3361 + glRotatef
3362 + glScaled
3363 + glScalef
3364 + glTranslated
3365 + glTranslatef
3366 + glViewport
3367 + glArrayElement
3368 + glColorPointer
3369 + glDisableClientState
3370 + glDrawArrays
3371 + glDrawElements
3372 + glEdgeFlagPointer
3373 + glEnableClientState
3374 + glGetPointerv
3375 + glIndexPointer
3376 + glInterleavedArrays
3377 + glNormalPointer
3378 + glTexCoordPointer
3379 + glVertexPointer
3380 + glPolygonOffset
3381 + glCopyTexImage1D
3382 + glCopyTexImage2D
3383 + glCopyTexSubImage1D
3384 + glCopyTexSubImage2D
3385 + glTexSubImage1D
3386 + glTexSubImage2D
3387 + glAreTexturesResident
3388 + glBindTexture
3389 + glDeleteTextures
3390 + glGenTextures
3391 + glIsTexture
3392 + glPrioritizeTextures
3393 + glIndexub
3394 + glIndexubv
3395 + glPopClientAttrib
3396 + glPushClientAttrib
3397 + glBlendColor
3398 + glBlendEquation
3399 + glDrawRangeElements
3400 + glColorTable
3401 + glColorTableParameterfv
3402 + glColorTableParameteriv
3403 + glCopyColorTable
3404 + glGetColorTable
3405 + glGetColorTableParameterfv
3406 + glGetColorTableParameteriv
3407 + glColorSubTable
3408 + glCopyColorSubTable
3409 + glConvolutionFilter1D
3410 + glConvolutionFilter2D
3411 + glConvolutionParameterf
3412 + glConvolutionParameterfv
3413 + glConvolutionParameteri
3414 + glConvolutionParameteriv
3415 + glCopyConvolutionFilter1D
3416 + glCopyConvolutionFilter2D
3417 + glGetConvolutionFilter
3418 + glGetConvolutionParameterfv
3419 + glGetConvolutionParameteriv
3420 + glGetSeparableFilter
3421 + glSeparableFilter2D
3422 + glGetHistogram
3423 + glGetHistogramParameterfv
3424 + glGetHistogramParameteriv
3425 + glGetMinmax
3426 + glGetMinmaxParameterfv
3427 + glGetMinmaxParameteriv
3428 + glHistogram
3429 + glMinmax
3430 + glResetHistogram
3431 + glResetMinmax
3432 + glTexImage3D
3433 + glTexSubImage3D
3434 + glCopyTexSubImage3D
3435 + glActiveTextureARB
3436 + glClientActiveTextureARB
3437 + glMultiTexCoord1dARB
3438 + glMultiTexCoord1dvARB
3439 + glMultiTexCoord1fARB
3440 + glMultiTexCoord1fvARB
3441 + glMultiTexCoord1iARB
3442 + glMultiTexCoord1ivARB
3443 + glMultiTexCoord1sARB
3444 + glMultiTexCoord1svARB
3445 + glMultiTexCoord2dARB
3446 + glMultiTexCoord2dvARB
3447 + glMultiTexCoord2fARB
3448 + glMultiTexCoord2fvARB
3449 + glMultiTexCoord2iARB
3450 + glMultiTexCoord2ivARB
3451 + glMultiTexCoord2sARB
3452 + glMultiTexCoord2svARB
3453 + glMultiTexCoord3dARB
3454 + glMultiTexCoord3dvARB
3455 + glMultiTexCoord3fARB
3456 + glMultiTexCoord3fvARB
3457 + glMultiTexCoord3iARB
3458 + glMultiTexCoord3ivARB
3459 + glMultiTexCoord3sARB
3460 + glMultiTexCoord3svARB
3461 + glMultiTexCoord4dARB
3462 + glMultiTexCoord4dvARB
3463 + glMultiTexCoord4fARB
3464 + glMultiTexCoord4fvARB
3465 + glMultiTexCoord4iARB
3466 + glMultiTexCoord4ivARB
3467 + glMultiTexCoord4sARB
3468 + glMultiTexCoord4svARB
3469 + glLoadTransposeMatrixfARB
3470 + glLoadTransposeMatrixdARB
3471 + glMultTransposeMatrixfARB
3472 + glMultTransposeMatrixdARB
3473 + glSampleCoverageARB
3474 + glCompressedTexImage3DARB
3475 + glCompressedTexImage2DARB
3476 + glCompressedTexImage1DARB
3477 + glCompressedTexSubImage3DARB
3478 + glCompressedTexSubImage2DARB
3479 + glCompressedTexSubImage1DARB
3480 + glGetCompressedTexImageARB
3481 + glActiveTexture
3482 + glClientActiveTexture
3483 + glMultiTexCoord1d
3484 + glMultiTexCoord1dv
3485 + glMultiTexCoord1f
3486 + glMultiTexCoord1fv
3487 + glMultiTexCoord1i
3488 + glMultiTexCoord1iv
3489 + glMultiTexCoord1s
3490 + glMultiTexCoord1sv
3491 + glMultiTexCoord2d
3492 + glMultiTexCoord2dv
3493 + glMultiTexCoord2f
3494 + glMultiTexCoord2fv
3495 + glMultiTexCoord2i
3496 + glMultiTexCoord2iv
3497 + glMultiTexCoord2s
3498 + glMultiTexCoord2sv
3499 + glMultiTexCoord3d
3500 + glMultiTexCoord3dv
3501 + glMultiTexCoord3f
3502 + glMultiTexCoord3fv
3503 + glMultiTexCoord3i
3504 + glMultiTexCoord3iv
3505 + glMultiTexCoord3s
3506 + glMultiTexCoord3sv
3507 + glMultiTexCoord4d
3508 + glMultiTexCoord4dv
3509 + glMultiTexCoord4f
3510 + glMultiTexCoord4fv
3511 + glMultiTexCoord4i
3512 + glMultiTexCoord4iv
3513 + glMultiTexCoord4s
3514 + glMultiTexCoord4sv
3515 + glLoadTransposeMatrixf
3516 + glLoadTransposeMatrixd
3517 + glMultTransposeMatrixf
3518 + glMultTransposeMatrixd
3519 + glSampleCoverage
3520 + glCompressedTexImage3D
3521 + glCompressedTexImage2D
3522 + glCompressedTexImage1D
3523 + glCompressedTexSubImage3D
3524 + glCompressedTexSubImage2D
3525 + glCompressedTexSubImage1D
3526 + glGetCompressedTexImage
3527 + glBlendColorEXT
3528 + glPolygonOffsetEXT
3529 + glTexImage3DEXT
3530 + glTexSubImage3DEXT
3531 + glTexSubImage1DEXT
3532 + glTexSubImage2DEXT
3533 + glCopyTexImage1DEXT
3534 + glCopyTexImage2DEXT
3535 + glCopyTexSubImage1DEXT
3536 + glCopyTexSubImage2DEXT
3537 + glCopyTexSubImage3DEXT
3538 + glAreTexturesResidentEXT
3539 + glBindTextureEXT
3540 + glDeleteTexturesEXT
3541 + glGenTexturesEXT
3542 + glIsTextureEXT
3543 + glPrioritizeTexturesEXT
3544 + glArrayElementEXT
3545 + glColorPointerEXT
3546 + glDrawArraysEXT
3547 + glEdgeFlagPointerEXT
3548 + glGetPointervEXT
3549 + glIndexPointerEXT
3550 + glNormalPointerEXT
3551 + glTexCoordPointerEXT
3552 + glVertexPointerEXT
3553 + glBlendEquationEXT
3554 + glPointParameterfEXT
3555 + glPointParameterfvEXT
3556 + glPointParameterfARB
3557 + glPointParameterfvARB
3558 + glColorTableEXT
3559 + glGetColorTableEXT
3560 + glGetColorTableParameterivEXT
3561 + glGetColorTableParameterfvEXT
3562 + glLockArraysEXT
3563 + glUnlockArraysEXT
3564 + glDrawRangeElementsEXT
3565 + glSecondaryColor3bEXT
3566 + glSecondaryColor3bvEXT
3567 + glSecondaryColor3dEXT
3568 + glSecondaryColor3dvEXT
3569 + glSecondaryColor3fEXT
3570 + glSecondaryColor3fvEXT
3571 + glSecondaryColor3iEXT
3572 + glSecondaryColor3ivEXT
3573 + glSecondaryColor3sEXT
3574 + glSecondaryColor3svEXT
3575 + glSecondaryColor3ubEXT
3576 + glSecondaryColor3ubvEXT
3577 + glSecondaryColor3uiEXT
3578 + glSecondaryColor3uivEXT
3579 + glSecondaryColor3usEXT
3580 + glSecondaryColor3usvEXT
3581 + glSecondaryColorPointerEXT
3582 + glMultiDrawArraysEXT
3583 + glMultiDrawElementsEXT
3584 + glFogCoordfEXT
3585 + glFogCoordfvEXT
3586 + glFogCoorddEXT
3587 + glFogCoorddvEXT
3588 + glFogCoordPointerEXT
3589 + glBlendFuncSeparateEXT
3590 + glFlushVertexArrayRangeNV
3591 + glVertexArrayRangeNV
3592 + glCombinerParameterfvNV
3593 + glCombinerParameterfNV
3594 + glCombinerParameterivNV
3595 + glCombinerParameteriNV
3596 + glCombinerInputNV
3597 + glCombinerOutputNV
3598 + glFinalCombinerInputNV
3599 + glGetCombinerInputParameterfvNV
3600 + glGetCombinerInputParameterivNV
3601 + glGetCombinerOutputParameterfvNV
3602 + glGetCombinerOutputParameterivNV
3603 + glGetFinalCombinerInputParameterfvNV
3604 + glGetFinalCombinerInputParameterivNV
3605 + glResizeBuffersMESA
3606 + glWindowPos2dMESA
3607 + glWindowPos2dvMESA
3608 + glWindowPos2fMESA
3609 + glWindowPos2fvMESA
3610 + glWindowPos2iMESA
3611 + glWindowPos2ivMESA
3612 + glWindowPos2sMESA
3613 + glWindowPos2svMESA
3614 + glWindowPos3dMESA
3615 + glWindowPos3dvMESA
3616 + glWindowPos3fMESA
3617 + glWindowPos3fvMESA
3618 + glWindowPos3iMESA
3619 + glWindowPos3ivMESA
3620 + glWindowPos3sMESA
3621 + glWindowPos3svMESA
3622 + glWindowPos4dMESA
3623 + glWindowPos4dvMESA
3624 + glWindowPos4fMESA
3625 + glWindowPos4fvMESA
3626 + glWindowPos4iMESA
3627 + glWindowPos4ivMESA
3628 + glWindowPos4sMESA
3629 + glWindowPos4svMESA
3630 + glWindowPos2dARB
3631 + glWindowPos2fARB
3632 + glWindowPos2iARB
3633 + glWindowPos2sARB
3634 + glWindowPos2dvARB
3635 + glWindowPos2fvARB
3636 + glWindowPos2ivARB
3637 + glWindowPos2svARB
3638 + glWindowPos3dARB
3639 + glWindowPos3fARB
3640 + glWindowPos3iARB
3641 + glWindowPos3sARB
3642 + glWindowPos3dvARB
3643 + glWindowPos3fvARB
3644 + glWindowPos3ivARB
3645 + glWindowPos3svARB
3646 + glAreProgramsResidentNV
3647 + glBindProgramNV
3648 + glDeleteProgramsNV
3649 + glExecuteProgramNV
3650 + glGenProgramsNV
3651 + glGetProgramParameterdvNV
3652 + glGetProgramParameterfvNV
3653 + glGetProgramivNV
3654 + glGetProgramStringNV
3655 + glGetTrackMatrixivNV
3656 + glGetVertexAttribdvNV
3657 + glGetVertexAttribfvNV
3658 + glGetVertexAttribivNV
3659 + glGetVertexAttribPointervNV
3660 + glIsProgramNV
3661 + glLoadProgramNV
3662 + glProgramParameter4dNV
3663 + glProgramParameter4dvNV
3664 + glProgramParameter4fNV
3665 + glProgramParameter4fvNV
3666 + glProgramParameters4dvNV
3667 + glProgramParameters4fvNV
3668 + glRequestResidentProgramsNV
3669 + glTrackMatrixNV
3670 + glVertexAttribPointerNV
3671 + glVertexAttrib1dNV
3672 + glVertexAttrib1dvNV
3673 + glVertexAttrib1fNV
3674 + glVertexAttrib1fvNV
3675 + glVertexAttrib1sNV
3676 + glVertexAttrib1svNV
3677 + glVertexAttrib2dNV
3678 + glVertexAttrib2dvNV
3679 + glVertexAttrib2fNV
3680 + glVertexAttrib2fvNV
3681 + glVertexAttrib2sNV
3682 + glVertexAttrib2svNV
3683 + glVertexAttrib3dNV
3684 + glVertexAttrib3dvNV
3685 + glVertexAttrib3fNV
3686 + glVertexAttrib3fvNV
3687 + glVertexAttrib3sNV
3688 + glVertexAttrib3svNV
3689 + glVertexAttrib4dNV
3690 + glVertexAttrib4dvNV
3691 + glVertexAttrib4fNV
3692 + glVertexAttrib4fvNV
3693 + glVertexAttrib4sNV
3694 + glVertexAttrib4svNV
3695 + glVertexAttrib4ubNV
3696 + glVertexAttrib4ubvNV
3697 + glVertexAttribs1dvNV
3698 + glVertexAttribs1fvNV
3699 + glVertexAttribs1svNV
3700 + glVertexAttribs2dvNV
3701 + glVertexAttribs2fvNV
3702 + glVertexAttribs2svNV
3703 + glVertexAttribs3dvNV
3704 + glVertexAttribs3fvNV
3705 + glVertexAttribs3svNV
3706 + glVertexAttribs4dvNV
3707 + glVertexAttribs4fvNV
3708 + glVertexAttribs4svNV
3709 + glVertexAttribs4ubvNV
3710 + glPointParameteriNV
3711 + glPointParameterivNV
3712 + glFogCoordf
3713 + glFogCoordfv
3714 + glFogCoordd
3715 + glFogCoorddv
3716 + glFogCoordPointer
3717 + glMultiDrawArrays
3718 + glMultiDrawElements
3719 + glPointParameterf
3720 + glPointParameterfv
3721 + glPointParameteri
3722 + glPointParameteriv
3723 + glSecondaryColor3b
3724 + glSecondaryColor3bv
3725 + glSecondaryColor3d
3726 + glSecondaryColor3dv
3727 + glSecondaryColor3f
3728 + glSecondaryColor3fv
3729 + glSecondaryColor3i
3730 + glSecondaryColor3iv
3731 + glSecondaryColor3s
3732 + glSecondaryColor3sv
3733 + glSecondaryColor3ub
3734 + glSecondaryColor3ubv
3735 + glSecondaryColor3ui
3736 + glSecondaryColor3uiv
3737 + glSecondaryColor3us
3738 + glSecondaryColor3usv
3739 + glSecondaryColorPointer
3740 + glWindowPos2d
3741 + glWindowPos2dv
3742 + glWindowPos2f
3743 + glWindowPos2fv
3744 + glWindowPos2i
3745 + glWindowPos2iv
3746 + glWindowPos2s
3747 + glWindowPos2sv
3748 + glWindowPos3d
3749 + glWindowPos3dv
3750 + glWindowPos3f
3751 + glWindowPos3fv
3752 + glWindowPos3i
3753 + glWindowPos3iv
3754 + glWindowPos3s
3755 + glWindowPos3sv
3756 + glVertexAttrib1sARB
3757 + glVertexAttrib1fARB
3758 + glVertexAttrib1dARB
3759 + glVertexAttrib2sARB
3760 + glVertexAttrib2fARB
3761 + glVertexAttrib2dARB
3762 + glVertexAttrib3sARB
3763 + glVertexAttrib3fARB
3764 + glVertexAttrib3dARB
3765 + glVertexAttrib4sARB
3766 + glVertexAttrib4fARB
3767 + glVertexAttrib4dARB
3768 + glVertexAttrib4NubARB
3769 + glVertexAttrib1svARB
3770 + glVertexAttrib1fvARB
3771 + glVertexAttrib1dvARB
3772 + glVertexAttrib2svARB
3773 + glVertexAttrib2fvARB
3774 + glVertexAttrib2dvARB
3775 + glVertexAttrib3svARB
3776 + glVertexAttrib3fvARB
3777 + glVertexAttrib3dvARB
3778 + glVertexAttrib4bvARB
3779 + glVertexAttrib4svARB
3780 + glVertexAttrib4ivARB
3781 + glVertexAttrib4ubvARB
3782 + glVertexAttrib4usvARB
3783 + glVertexAttrib4uivARB
3784 + glVertexAttrib4fvARB
3785 + glVertexAttrib4dvARB
3786 + glVertexAttrib4NbvARB
3787 + glVertexAttrib4NsvARB
3788 + glVertexAttrib4NivARB
3789 + glVertexAttrib4NubvARB
3790 + glVertexAttrib4NusvARB
3791 + glVertexAttrib4NuivARB
3792 + glVertexAttribPointerARB
3793 + glEnableVertexAttribArrayARB
3794 + glDisableVertexAttribArrayARB
3795 + glProgramStringARB
3796 + glBindProgramARB
3797 + glDeleteProgramsARB
3798 + glGenProgramsARB
3799 + glIsProgramARB
3800 + glProgramEnvParameter4dARB
3801 + glProgramEnvParameter4dvARB
3802 + glProgramEnvParameter4fARB
3803 + glProgramEnvParameter4fvARB
3804 + glProgramLocalParameter4dARB
3805 + glProgramLocalParameter4dvARB
3806 + glProgramLocalParameter4fARB
3807 + glProgramLocalParameter4fvARB
3808 + glGetProgramEnvParameterdvARB
3809 + glGetProgramEnvParameterfvARB
3810 + glGetProgramLocalParameterdvARB
3811 + glGetProgramLocalParameterfvARB
3812 + glGetProgramivARB
3813 + glGetProgramStringARB
3814 + glGetVertexAttribdvARB
3815 + glGetVertexAttribfvARB
3816 + glGetVertexAttribivARB
3817 + glGetVertexAttribPointervARB
3818 + glProgramNamedParameter4fNV
3819 + glProgramNamedParameter4dNV
3820 + glProgramNamedParameter4fvNV
3821 + glProgramNamedParameter4dvNV
3822 + glGetProgramNamedParameterfvNV
3823 + glGetProgramNamedParameterdvNV
3824 + glBindBufferARB
3825 + glBufferDataARB
3826 + glBufferSubDataARB
3827 + glDeleteBuffersARB
3828 + glGenBuffersARB
3829 + glGetBufferParameterivARB
3830 + glGetBufferPointervARB
3831 + glGetBufferSubDataARB
3832 + glIsBufferARB
3833 + glMapBufferARB
3834 + glUnmapBufferARB
3835 + glGenQueriesARB
3836 + glDeleteQueriesARB
3837 + glIsQueryARB
3838 + glBeginQueryARB
3839 + glEndQueryARB
3840 + glGetQueryivARB
3841 + glGetQueryObjectivARB
3842 + glGetQueryObjectuivARB
3843 + glBindBuffer
3844 + glBufferData
3845 + glBufferSubData
3846 + glDeleteBuffers
3847 + glGenBuffers
3848 + glGetBufferParameteriv
3849 + glGetBufferPointerv
3850 + glGetBufferSubData
3851 + glIsBuffer
3852 + glMapBuffer
3853 + glUnmapBuffer
3854 + glGenQueries
3855 + glDeleteQueries
3856 + glIsQuery
3857 + glBeginQuery
3858 + glEndQuery
3859 + glGetQueryiv
3860 + glGetQueryObjectiv
3861 + glGetQueryObjectuiv
3862 +
3863 +
3864 +;
3865 +; Mesa internals - mostly for OSMESA
3866 + _vbo_CreateContext
3867 + _vbo_DestroyContext
3868 + _vbo_InvalidateState
3869 + _glapi_check_multithread
3870 + _glapi_get_context
3871 + _glapi_get_proc_address
3872 + _mesa_add_soft_renderbuffers
3873 + _mesa_add_renderbuffer
3874 + _mesa_begin_query
3875 + _mesa_buffer_data
3876 + _mesa_buffer_get_subdata
3877 + _mesa_buffer_map
3878 + _mesa_buffer_subdata
3879 + _mesa_buffer_unmap
3880 + _mesa_bzero
3881 + _mesa_calloc
3882 + _mesa_choose_tex_format
3883 + _mesa_compressed_texture_size
3884 + _mesa_create_framebuffer
3885 + _mesa_create_visual
3886 + _mesa_delete_array_object
3887 + _mesa_delete_buffer_object
3888 + _mesa_delete_program
3889 + _mesa_delete_query
3890 + _mesa_delete_texture_object
3891 + _mesa_destroy_framebuffer
3892 + _mesa_destroy_visual
3893 + _mesa_enable_1_3_extensions
3894 + _mesa_enable_1_4_extensions
3895 + _mesa_enable_1_5_extensions
3896 + _mesa_enable_2_0_extensions
3897 + _mesa_enable_2_1_extensions
3898 + _mesa_enable_sw_extensions
3899 + _mesa_end_query
3900 + _mesa_error
3901 + _mesa_finish_render_texture
3902 + _mesa_framebuffer_renderbuffer
3903 + _mesa_free
3904 + _mesa_free_context_data
3905 + _mesa_free_texture_image_data
3906 + _mesa_generate_mipmap
3907 + _mesa_get_compressed_teximage
3908 + _mesa_get_current_context
3909 + _mesa_get_program_register
3910 + _mesa_get_teximage
3911 + _mesa_init_driver_functions
3912 + _mesa_init_glsl_driver_functions
3913 + _mesa_init_renderbuffer
3914 + _mesa_initialize_context
3915 + _mesa_make_current
3916 + _mesa_memcpy
3917 + _mesa_memset
3918 + _mesa_new_array_object
3919 + _mesa_new_buffer_object
3920 + _mesa_new_framebuffer
3921 + _mesa_new_program
3922 + _mesa_new_query_object
3923 + _mesa_new_renderbuffer
3924 + _mesa_new_soft_renderbuffer
3925 + _mesa_new_texture_image
3926 + _mesa_new_texture_object
3927 + _mesa_problem
3928 + _mesa_reference_renderbuffer
3929 + _mesa_remove_renderbuffer
3930 + _mesa_render_texture
3931 + _mesa_ResizeBuffersMESA
3932 + _mesa_resize_framebuffer
3933 + _mesa_store_compressed_teximage1d
3934 + _mesa_store_compressed_teximage2d
3935 + _mesa_store_compressed_teximage3d
3936 + _mesa_store_compressed_texsubimage1d
3937 + _mesa_store_compressed_texsubimage2d
3938 + _mesa_store_compressed_texsubimage3d
3939 + _mesa_store_teximage1d
3940 + _mesa_store_teximage2d
3941 + _mesa_store_teximage3d
3942 + _mesa_store_texsubimage1d
3943 + _mesa_store_texsubimage2d
3944 + _mesa_store_texsubimage3d
3945 + _mesa_strcmp
3946 + _mesa_test_proxy_teximage
3947 + _mesa_unreference_framebuffer
3948 + _mesa_update_framebuffer_visual
3949 + _mesa_use_program
3950 + _mesa_Viewport
3951 + _mesa_wait_query
3952 + _swrast_Accum
3953 + _swrast_Bitmap
3954 + _swrast_BlitFramebuffer
3955 + _swrast_CopyPixels
3956 + _swrast_DrawPixels
3957 + _swrast_GetDeviceDriverReference
3958 + _swrast_Clear
3959 + _swrast_choose_line
3960 + _swrast_choose_triangle
3961 + _swrast_CopyColorSubTable
3962 + _swrast_CopyColorTable
3963 + _swrast_CopyConvolutionFilter1D
3964 + _swrast_CopyConvolutionFilter2D
3965 + _swrast_copy_teximage1d
3966 + _swrast_copy_teximage2d
3967 + _swrast_copy_texsubimage1d
3968 + _swrast_copy_texsubimage2d
3969 + _swrast_copy_texsubimage3d
3970 + _swrast_CreateContext
3971 + _swrast_DestroyContext
3972 + _swrast_exec_fragment_program
3973 + _swrast_InvalidateState
3974 + _swrast_ReadPixels
3975 + _swsetup_Wakeup
3976 + _swsetup_CreateContext
3977 + _swsetup_DestroyContext
3978 + _swsetup_InvalidateState
3979 + _tnl_CreateContext
3980 + _tnl_DestroyContext
3981 + _tnl_InvalidateState
3982 + _tnl_run_pipeline
3983 + _tnl_program_string
3984 + _tnl_RasterPos
3985 Index: x86/common_x86.c
3986 ===================================================================
3987 --- x86/common_x86.c (revision 7)
3988 +++ x86/common_x86.c (working copy)
3989 @@ -160,7 +160,7 @@
3990 if ( cpu_has_xmm ) {
3991 _mesa_debug(NULL, "Testing OS support for SSE unmasked exceptions...\n");
3992
3993 - _mesa_test_os_sse_exception_support();
3994 + //_mesa_test_os_sse_exception_support();
3995
3996 if ( cpu_has_xmm ) {
3997 _mesa_debug(NULL, "Yes.\n");
3998 Index: main/imports.c
3999 ===================================================================
4000 --- main/imports.c (revision 42472)
4001 +++ main/imports.c (working copy)
4002 @@ -104,7 +104,7 @@
4003
4004 (void) posix_memalign(& mem, alignment, bytes);
4005 return mem;
4006 -#elif defined(_WIN32) && defined(_MSC_VER)
4007 +#elif 0/*defined(_WIN32) && defined(_MSC_VER)*/
4008 return _aligned_malloc(bytes, alignment);
4009 #else
4010 uintptr_t ptr, buf;
4011 @@ -146,7 +146,7 @@
4012 }
4013
4014 return mem;
4015 -#elif defined(_WIN32) && defined(_MSC_VER)
4016 +#elif 0/*defined(_WIN32) && defined(_MSC_VER)*/
4017 void *mem;
4018
4019 mem = _aligned_malloc(bytes, alignment);
4020 Index: main/imports.h
4021 ===================================================================
4022 --- main/imports.h (revision 42472)
4023 +++ main/imports.h (working copy)
4024 @@ -482,10 +482,10 @@
4025 /* This function/macro is sensitive to precision. Test very carefully
4026 * if you change it!
4027 */
4028 -#define UNCLAMPED_FLOAT_TO_UBYTE(UB, F) \
4029 +#define UNCLAMPED_FLOAT_TO_UBYTE(UB, F_) \
4030 do { \
4031 fi_type __tmp; \
4032 - __tmp.f = (F); \
4033 + __tmp.f = (F_); \
4034 if (__tmp.i < 0) \
4035 UB = (GLubyte) 0; \
4036 else if (__tmp.i >= IEEE_0996) \
4037 @@ -495,10 +495,10 @@
4038 UB = (GLubyte) __tmp.i; \
4039 } \
4040 } while (0)
4041 -#define CLAMPED_FLOAT_TO_UBYTE(UB, F) \
4042 +#define CLAMPED_FLOAT_TO_UBYTE(UB, F_) \
4043 do { \
4044 fi_type __tmp; \
4045 - __tmp.f = (F) * (255.0F/256.0F) + 32768.0F; \
4046 + __tmp.f = (F_) * (255.0F/256.0F) + 32768.0F; \
4047 UB = (GLubyte) __tmp.i; \
4048 } while (0)
4049 #else
A free Windows-compatible Operating System