source: trunk/src/opengl/opengl32.cpp@ 2804

Last change on this file since 2804 was 2689, checked in by jeroen, 26 years ago

* empty log message *
File size: 69.8 KB
Line 
1/* $Id: opengl32.cpp,v 1.4 2000-02-09 08:50:54 jeroen Exp $ */
2/*****************************************************************************/
3/* */
4/* OpenGL32 */
5/* */
6/*****************************************************************************/
7#define INCL_BASE
8#include <os2wrap.h>
9#include <misc.h>
10#include <malloc.h>
11#include <memory.h>
12#include <float.h>
13
14#include "pglos2.h"
15#include "initterm.h"
16
17HWND WIN32API WindowFromDC(HDC hdc);
18HWND Win32ToOS2Handle(HWND hwnd);
19HWND OS2ToWin32Handle(HWND hwnd);
20LRESULT WIN32API SendMessageA(HWND,ULONG,WPARAM,LPARAM);
21
22#define PFD_TYPE_RGBA 0
23#define PFD_TYPE_COLORINDEX 1
24
25#define PFD_MAIN_PLANE 0
26#define PFD_OVERLAY_PLANE 1
27#define PFD_UNDERLAY_PLANE (-1)
28
29#define PFD_DOUBLEBUFFER 0x00000001
30#define PFD_STEREO 0x00000002
31#define PFD_DRAW_TO_WINDOW 0x00000004
32#define PFD_DRAW_TO_BITMAP 0x00000008
33#define PFD_SUPPORT_GDI 0x00000010
34#define PFD_SUPPORT_OPENGL 0x00000020
35#define PFD_GENERIC_FORMAT 0x00000040
36#define PFD_NEED_PALETTE 0x00000080
37#define PFD_NEED_SYSTEM_PALETTE 0x00000100
38#define PFD_SWAP_EXCHANGE 0x00000200
39#define PFD_SWAP_COPY 0x00000400
40#define PFD_SWAP_LAYER_BUFFERS 0x00000800
41#define PFD_GENERIC_ACCELERATED 0x00001000
42
43#define PFD_DEPTH_DONTCARE 0x20000000
44#define PFD_DOUBLEBUFFER_DONTCARE 0x40000000
45#define PFD_STEREO_DONTCARE 0x80000000
46
47typedef DWORD COLORREF;
48
49#pragma pack(1)
50typedef struct tagPIXELFORMATDESCRIPTOR {
51 WORD nSize;
52 WORD nVersion;
53 DWORD dwFlags;
54 BYTE iPixelType;
55 BYTE cColorBits;
56 BYTE cRedBits;
57 BYTE cRedShift;
58 BYTE cGreenBits;
59 BYTE cGreenShift;
60 BYTE cBlueBits;
61 BYTE cBlueShift;
62 BYTE cAlphaBits;
63 BYTE cAlphaShift;
64 BYTE cAccumBits;
65 BYTE cAccumRedBits;
66 BYTE cAccumGreenBits;
67 BYTE cAccumBlueBits;
68 BYTE cAccumAlphaBits;
69 BYTE cDepthBits;
70 BYTE cStencilBits;
71 BYTE cAuxBuffers;
72 BYTE iLayerType;
73 BYTE bReserved;
74 DWORD dwLayerMask;
75 DWORD dwVisibleMask;
76 DWORD dwDamageMask;
77} PIXELFORMATDESCRIPTOR, *LPPIXELFORMATDESCRIPTOR;
78
79typedef struct tagLAYERPLANEDESCRIPTOR {
80 WORD nSize;
81 WORD nVersion;
82 DWORD dwFlags;
83 BYTE iPixelType;
84 BYTE cColorBits;
85 BYTE cRedBits;
86 BYTE cRedShifts;
87 BYTE cGreenBits;
88 BYTE cGreenShifts;
89 BYTE cBlueBits;
90 BYTE cBlueShifts;
91 BYTE cAlphaBits;
92 BYTE cAlphaShifts;
93 BYTE cAccumBits;
94 BYTE cAccumRedBits;
95 BYTE cAccumGreenBits;
96 BYTE cAccumBlueBits;
97 BYTE cAccumAlphaBits;
98 BYTE cDepthBits;
99 BYTE cStencilBits;
100 BYTE cAuxBuffers;
101 BYTE iLayerPlane;
102 BYTE bReserved;
103 COLORREF crTransparent;
104} LAYERPLANEDESCRIPTOR;
105
106/* This structure is set by ChoosePixelConfig - it ties together the HDC, */
107/* PIXELFORMATDESCRIPTOR etc */
108typedef struct tagPFDINFO
109 {
110 HWND hwnd;
111 HDC hdc;
112 HGC hgc;
113 PIXELFORMATDESCRIPTOR pfd;
114 int iFormatSelected;
115 struct tagPFDINFO *Next;
116 }PFDINFO;
117#pragma pack()
118
119/*****************************************************************************/
120/* */
121/* Global variabled used in this DLL */
122/* */
123/*****************************************************************************/
124
125PFDINFO *pfdis = NULL;
126PVISUALCONFIG *global_visual_config_list = NULL;
127int global_visual_config_count= 0;
128HMTX hmtxPfdInfo;
129
130/*****************************************************************************/
131/* */
132/* DEBUG stuff - dump structures to the log... */
133/* */
134/*****************************************************************************/
135
136#ifdef DEBUG
137void PixFmtDump(PIXELFORMATDESCRIPTOR *p)
138{
139 dprintf(("*** PIXELFORMATDESCRIPTOR DUMP ***\n"));
140 dprintf(("PIXFMT.nSize: %d\n",p->nSize));
141 dprintf(("PIXFMT.nVersion: %d\n",p->nVersion));
142 dprintf(("PIXFMT.dwFlags: %08X\n",p->dwFlags));
143 dprintf(("PIXFMT.iPixelType: %d\n",p->iPixelType));
144 dprintf(("PIXFMT.cColorBits: %d\n",p->cColorBits));
145 dprintf(("PIXFMT.cRedBits: %d\n",p->cRedBits));
146 dprintf(("PIXFMT.cRedShift: %d\n",p->cRedShift));
147 dprintf(("PIXFMT.cGreenBits: %d\n",p->cGreenBits));
148 dprintf(("PIXFMT.cGreenShift: %d\n",p->cGreenShift));
149 dprintf(("PIXFMT.cBlueBits: %d\n",p->cBlueBits));
150 dprintf(("PIXFMT.cBlueShift: %d\n",p->cBlueShift));
151 dprintf(("PIXFMT.cAlphaBits: %d\n",p->cAlphaBits));
152 dprintf(("PIXFMT.cAlphaShift: %d\n",p->cAlphaShift));
153 dprintf(("PIXFMT.cAccumBits: %d\n",p->cAccumBits));
154 dprintf(("PIXFMT.cAccumRedBits: %d\n",p->cAccumRedBits));
155 dprintf(("PIXFMT.cAccumGreenBits: %d\n",p->cAccumGreenBits));
156 dprintf(("PIXFMT.cAccumAlphaBits: %d\n",p->cAccumAlphaBits));
157 dprintf(("PIXFMT.cAccumBlueBits: %d\n",p->cAccumBlueBits));
158 dprintf(("PIXFMT.cDepthBits: %d\n",p->cDepthBits));
159 dprintf(("PIXFMT.cStencilBits: %d\n",p->cStencilBits));
160 dprintf(("PIXFMT.cAuxBuffers: %d\n",p->cAuxBuffers));
161 dprintf(("PIXFMT.iLayerType: %d\n",p->iLayerType));
162 dprintf(("PIXFMT.dwLayerMask: %d\n",p->dwLayerMask));
163 dprintf(("PIXFMT.dwVisibleMask: %d\n",p->dwVisibleMask));
164 dprintf(("PIXFMT.dwDamageMask: %d\n",p->dwDamageMask));
165}
166
167void VisCfgDump(VISUALCONFIG *p)
168{
169 dprintf(("*** VISUALCONFIG DUMP ***\n"));
170 dprintf(("VISCFG.vid: %d\n",p->vid));
171 dprintf(("VISCFG.rgba: %d\n",p->rgba));
172 dprintf(("VISCFG.redSize: %d\n",p->redSize));
173 dprintf(("VISCFG.greenSize: %d\n",p->greenSize));
174 dprintf(("VISCFG.blueSize: %d\n",p->blueSize));
175 dprintf(("VISCFG.alphaSize: %d\n",p->alphaSize));
176 dprintf(("VISCFG.redMask: %08X\n",p->redMask));
177 dprintf(("VISCFG.greenMask: %08X\n",p->greenMask));
178 dprintf(("VISCFG.blueMask: %08X\n",p->blueMask));
179 dprintf(("VISCFG.accumRedSize: %d\n",p->accumRedSize));
180 dprintf(("VISCFG.accumGreenSize: %d\n",p->accumGreenSize));
181 dprintf(("VISCFG.accumBlueSize: %d\n",p->accumBlueSize));
182 dprintf(("VISCFG.accumAlphaSize: %d\n",p->accumAlphaSize));
183 dprintf(("VISCFG.doubleBuffer: %d\n",p->doubleBuffer));
184 dprintf(("VISCFG.stereo: %d\n",p->stereo));
185 dprintf(("VISCFG.bufferSize: %d\n",p->bufferSize));
186 dprintf(("VISCFG.depthSize: %d\n",p->depthSize));
187 dprintf(("VISCFG.stencilSize: %d\n",p->stencilSize));
188 dprintf(("VISCFG.auxBuffers: %d\n",p->auxBuffers));
189 dprintf(("VISCFG.level: %d\n",p->level));
190}
191#endif
192
193/*****************************************************************************/
194/* */
195/* Internal code to maintain the pdfs structure list */
196/* */
197/*****************************************************************************/
198
199void pfdi_destroy_all(void)
200{
201 /* Destroy all allocated structures - called by DLL_term */
202 PFDINFO *pi=pfdis;
203
204 DosRequestMutexSem(hmtxPfdInfo,SEM_INDEFINITE_WAIT);
205
206 while(pi)
207 {
208 pfdis=pi->Next;
209
210 free(pi);
211
212 pi=pfdis;
213 }
214
215 DosReleaseMutexSem(hmtxPfdInfo);
216}
217
218void pfdi_update_or_create(HDC hdc,PIXELFORMATDESCRIPTOR *pfd)
219{
220 /* ChoosePixelFormat returns an index to the most suitable PFD */
221 /* In OS/2 GL a linked-list of VISUALCONFIGS is returned */
222 /* Link the request to the callee so that we can use it later on */
223 /* when SetPixelFormat and CreateContext are called. */
224 PFDINFO *pi=pfdis;
225 HWND hwnd=WindowFromDC(hdc);
226
227 DosRequestMutexSem(hmtxPfdInfo,SEM_INDEFINITE_WAIT);
228
229 while(pi)
230 {
231 if(pi->hwnd==hwnd)
232 {
233 pi->hdc=hdc;
234
235 memcpy(&pi->pfd,pfd,sizeof(PIXELFORMATDESCRIPTOR));
236
237 DosReleaseMutexSem(hmtxPfdInfo);
238
239 return;
240 }
241
242 pi=pi->Next;
243 }
244
245 pi=(PFDINFO *)calloc(sizeof(PFDINFO),1);
246
247 pi->hwnd=hwnd;
248 pi->hdc=hdc;
249
250 memcpy(&pi->pfd,pfd,sizeof(PIXELFORMATDESCRIPTOR));
251
252 pi->Next=pfdis;
253
254 pfdis=pi;
255
256 DosReleaseMutexSem(hmtxPfdInfo);
257}
258
259PFDINFO *query_pfdi_by_hdc(HDC hdc)
260{
261 /* Query based upon the HDC - internally map this to the hwnd belonging */
262 /* to the HDC, since GetDC returnes different HDC's for the same window! */
263 PFDINFO *pi=pfdis;
264 HWND hwnd=WindowFromDC(hdc);
265
266 DosRequestMutexSem(hmtxPfdInfo,SEM_INDEFINITE_WAIT);
267
268 while(pi)
269 {
270 if(pi->hwnd==hwnd)
271 {
272 DosReleaseMutexSem(hmtxPfdInfo);
273
274 return pi;
275 }
276
277 pi=pi->Next;
278 }
279
280 DosReleaseMutexSem(hmtxPfdInfo);
281
282 return NULL;
283}
284
285PFDINFO *query_pfdi_by_hwnd(HWND hwnd)
286{
287 /* Query an PFDINFO struct member based upon a hwnd */
288 PFDINFO *pi=pfdis;
289
290 DosRequestMutexSem(hmtxPfdInfo,SEM_INDEFINITE_WAIT);
291
292 while(pi)
293 {
294 if(pi->hwnd==hwnd)
295 {
296 DosReleaseMutexSem(hmtxPfdInfo);
297
298 return pi;
299 }
300
301 pi=pi->Next;
302 }
303
304 DosReleaseMutexSem(hmtxPfdInfo);
305
306 return NULL;
307}
308
309PFDINFO *query_pfdi_by_hgc(HGC hgc)
310{
311 /* Query an PFDINFO struct member based upon an hgc */
312 PFDINFO *pi=pfdis;
313
314 DosRequestMutexSem(hmtxPfdInfo,SEM_INDEFINITE_WAIT);
315
316 while(pi)
317 {
318 if(pi->hgc==hgc)
319 {
320 DosReleaseMutexSem(hmtxPfdInfo);
321
322 return pi;
323 }
324
325 pi=pi->Next;
326 }
327
328 DosReleaseMutexSem(hmtxPfdInfo);
329
330 return NULL;
331}
332
333void pfdi_purge(HDC hdc)
334{
335 /* Remove the PFDINFO for this hdc from the linked list */
336 PFDINFO *pi,*pi2=NULL;
337 HWND hwnd=WindowFromDC(hdc);
338
339 DosRequestMutexSem(hmtxPfdInfo,SEM_INDEFINITE_WAIT);
340
341 pi=pfdis;
342
343 while(pi)
344 {
345 if(pi->hwnd==hwnd)
346 {
347 if(pi2)
348 pi2->Next=pi->Next;
349 else
350 pfdis=pi->Next;
351
352 free(pi);
353
354 DosReleaseMutexSem(hmtxPfdInfo);
355
356 return;
357 }
358
359 pi2=pi; pi=pi->Next;
360 }
361
362 DosReleaseMutexSem(hmtxPfdInfo);
363}
364
365/***************************************************************************/
366/* */
367/* Internal Support Functions */
368/* */
369/***************************************************************************/
370
371void AttrAdd(int *attrs,int *attridx,int value)
372{
373 attrs[(*attridx)++]=value;
374}
375
376PVISUALCONFIG GL_QueryConfigs(HDC hdc,PIXELFORMATDESCRIPTOR *pfd)
377{
378 int attrs[40],attridx=0;
379 PVISUALCONFIG pvc;
380 PFDINFO *pfdi;
381
382 pfdi=query_pfdi_by_hdc(hdc);
383
384 if(pfd->dwFlags & PFD_SUPPORT_OPENGL)
385 {
386 AttrAdd(attrs,&attridx,PGL_USE_GL);
387 }
388
389 if(pfd->dwFlags & PFD_DOUBLEBUFFER && !(pfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE))
390 {
391 AttrAdd(attrs,&attridx,PGL_DOUBLEBUFFER);
392 }
393
394 if(pfd->dwFlags & PFD_STEREO && !(pfd->dwFlags & PFD_STEREO_DONTCARE))
395 {
396 AttrAdd(attrs,&attridx,PGL_STEREO);
397 }
398
399 switch(pfd->iPixelType)
400 {
401 case PFD_TYPE_RGBA:
402 AttrAdd(attrs,&attridx,PGL_RGBA);
403 break;
404
405 case PFD_TYPE_COLORINDEX:
406 break;
407 }
408
409 switch(pfd->iLayerType)
410 {
411 case PFD_MAIN_PLANE:
412 AttrAdd(attrs,&attridx,PGL_LEVEL);
413 AttrAdd(attrs,&attridx,0);
414 break;
415
416 case PFD_OVERLAY_PLANE:
417 AttrAdd(attrs,&attridx,PGL_LEVEL);
418 AttrAdd(attrs,&attridx,1);
419 break;
420
421 case PFD_UNDERLAY_PLANE:
422 AttrAdd(attrs,&attridx,PGL_LEVEL);
423 AttrAdd(attrs,&attridx,-1);
424 break;
425 }
426
427 if(pfd->cDepthBits)
428 {
429 AttrAdd(attrs,&attridx,PGL_DEPTH_SIZE);
430
431 /* Added JvdH - is my machine bogus? cDepthBits 32 returns no */
432 /* valid configs. Is this Matrox specific?? */
433
434 if(pfd->cDepthBits<=24)
435 AttrAdd(attrs,&attridx,pfd->cDepthBits);
436 else
437 AttrAdd(attrs,&attridx,24);
438 }
439
440 if(pfd->cColorBits)
441 {
442 AttrAdd(attrs,&attridx,PGL_BUFFER_SIZE);
443 AttrAdd(attrs,&attridx,pfd->cColorBits);
444 }
445
446 if(pfd->cAuxBuffers)
447 {
448 AttrAdd(attrs,&attridx,PGL_AUX_BUFFERS);
449 AttrAdd(attrs,&attridx,pfd->cAuxBuffers);
450 }
451
452 if(pfd->cRedBits)
453 {
454 AttrAdd(attrs,&attridx,PGL_RED_SIZE);
455 AttrAdd(attrs,&attridx,pfd->cRedBits);
456 }
457
458 if(pfd->cGreenBits)
459 {
460 AttrAdd(attrs,&attridx,PGL_GREEN_SIZE);
461 AttrAdd(attrs,&attridx,pfd->cGreenBits);
462 }
463
464 if(pfd->cBlueBits)
465 {
466 AttrAdd(attrs,&attridx,PGL_BLUE_SIZE);
467 AttrAdd(attrs,&attridx,pfd->cBlueBits);
468 }
469
470 if(pfd->cAlphaBits)
471 {
472 AttrAdd(attrs,&attridx,PGL_ALPHA_SIZE);
473 AttrAdd(attrs,&attridx,pfd->cAlphaBits);
474 }
475
476 if(pfd->cStencilBits)
477 {
478 AttrAdd(attrs,&attridx,PGL_STENCIL_SIZE);
479 AttrAdd(attrs,&attridx,pfd->cStencilBits);
480 }
481
482 AttrAdd(attrs,&attridx,None);
483
484 pvc=OS2pglChooseConfig(hdc,attrs);
485
486 return pvc;
487}
488
489int GL_VisualConfigIndex(PVISUALCONFIG pvc)
490{
491 int i;
492
493 for(i=0; i<global_visual_config_count; i++)
494 if(memcmp(global_visual_config_list[i],pvc,sizeof(VISUALCONFIG))==0)
495 return i+1;
496
497 dprintf(("OPENGL32 (ERROR): Could not map the VisualConfig %08X\n",pvc));
498
499 return 0;
500}
501
502void GL_VisualConfig_to_PixelFormat(HDC hdc,
503 VISUALCONFIG *pvc,
504 PIXELFORMATDESCRIPTOR *pfd)
505{
506 /* Map a VisualConfig structure to an identical PixelFmt structure */
507 /* Win32 uses PIXELFORMATDESCRIPTORs, whereas OS/2 uses VISUALCONFIGs */
508 PFDINFO *pfdi;
509 BOOL fDirect=FALSE;
510
511 pfdi=query_pfdi_by_hdc(hdc);
512
513 if(pfdi)
514 fDirect=(pfdi->pfd.dwFlags & PFD_DRAW_TO_WINDOW)?TRUE:FALSE;
515
516 memset(pfd,0,sizeof(PIXELFORMATDESCRIPTOR));
517
518 pfd->nSize=sizeof(PIXELFORMATDESCRIPTOR);
519 pfd->nVersion=1;
520
521 pfd->dwFlags=PFD_SUPPORT_OPENGL | (fDirect?PFD_DRAW_TO_WINDOW:0);
522
523 if(pvc->stereo)
524 pfd->dwFlags+=PFD_STEREO;
525
526 if(pvc->doubleBuffer)
527 pfd->dwFlags+=PFD_DOUBLEBUFFER;
528
529 if(pvc->rgba)
530 pfd->iPixelType=PFD_TYPE_RGBA;
531 else
532 pfd->iPixelType=PFD_TYPE_COLORINDEX;
533
534 pfd->cColorBits=pvc->bufferSize;
535 pfd->cRedBits=pvc->redSize;
536 pfd->cRedShift=0;
537 pfd->cGreenBits=pvc->greenSize;
538 pfd->cGreenShift=0;
539 pfd->cBlueBits=pvc->blueSize;
540 pfd->cBlueShift=0;
541 pfd->cAlphaBits=pvc->alphaSize;
542 pfd->cAlphaShift=0;
543 pfd->cAccumBits=0;
544 pfd->cAccumRedBits=pvc->accumRedSize;
545 pfd->cAccumGreenBits=pvc->accumGreenSize;
546 pfd->cAccumBlueBits=pvc->accumBlueSize;
547 pfd->cAccumAlphaBits=pvc->accumAlphaSize;
548 pfd->cDepthBits=pvc->depthSize;
549 pfd->cStencilBits=pvc->stencilSize;
550 pfd->cAuxBuffers=pvc->auxBuffers;
551
552 if(pvc->level<0)
553 pfd->iLayerType=PFD_UNDERLAY_PLANE;
554 else
555 if(pvc->level>0)
556 pfd->iLayerType=PFD_OVERLAY_PLANE;
557 else
558 pfd->iLayerType=PFD_MAIN_PLANE;
559
560 pfd->bReserved=0;
561 pfd->dwLayerMask=0;
562 pfd->dwVisibleMask=0;
563 pfd->dwDamageMask=0;
564}
565
566/***************************************************************************/
567/* */
568/* API Entry Points - Map calls to OPENGL.DLL */
569/* */
570/***************************************************************************/
571
572/***************************************************************************/
573/* */
574/* wgl->pgl Conversion functions */
575/* */
576/***************************************************************************/
577
578BOOL WIN32API wglSwapBuffers(HDC hdc)
579{
580 HWND hWnd;
581
582 hWnd=Win32ToOS2Handle(WindowFromDC(hdc));
583
584 if(hWnd)
585 OS2pglSwapBuffers(hdc,hWnd);
586
587 return hWnd!=NULL;
588}
589
590int WIN32API wglChoosePixelFormat(HDC hdc,PIXELFORMATDESCRIPTOR *pfd)
591{
592 /* The PixelFormatDescriptor hold information about the required context */
593 /* It is our task to return the 'most suitable one'. Translate the call */
594 /* to native OS/2 OpenGL and return a suitable value. */
595 PVISUALCONFIG pvc;
596
597#ifdef DEBUG
598 /* DUMP the pfd */
599 PixFmtDump(pfd);
600#endif
601
602 pfdi_update_or_create(hdc,pfd);
603
604 pvc=GL_QueryConfigs(hdc,pfd);
605
606 /* If no valid visualconfig is found there is really no need to keep the */
607 /* PFDINFO structure! */
608 if(!pvc)
609 {
610 pfdi_purge(hdc);
611 return 0;
612 }
613
614 return GL_VisualConfigIndex(pvc);
615}
616
617GLint WIN32API wglGetPixelFormat(HDC hdc)
618{
619 PFDINFO *pfdi;
620
621 pfdi=query_pfdi_by_hdc(hdc);
622
623 if(pfdi)
624 return pfdi->iFormatSelected;
625
626 return 0;
627}
628
629BOOL WIN32API wglSetPixelFormat(HDC hdc,
630 GLint iFormat,
631 PIXELFORMATDESCRIPTOR *pfd)
632{
633 /* Set the pixelformat - the pixelformat was chosen by wglChoosePixelFormat */
634 /* and stored in the PFDINFO linked list. We just check if the structure is */
635 /* present in the list. If not, return FALSE! */
636 PFDINFO *pfdi;
637
638 pfdi=query_pfdi_by_hdc(hdc);
639
640 if(pfdi)
641 {
642 pfdi->iFormatSelected=iFormat;
643
644 return TRUE;
645 }
646
647 return FALSE;
648}
649
650HGC WIN32API wglCreateContext(HDC hdc)
651{
652 /* The PFDINFO structure must be present (by a prev call to ChooseConfig !) */
653 /* If not chosen we don't know what we should return... */
654 PFDINFO *pfdi;
655 HGC hgc;
656 HGC sharelist=NULL;
657 PVISUALCONFIG pvc;
658
659 pfdi=query_pfdi_by_hdc(hdc);
660
661 if(pfdi)
662 {
663 if(pfdi->iFormatSelected>=1 && pfdi->iFormatSelected<=global_visual_config_count)
664 {
665 pvc=global_visual_config_list[pfdi->iFormatSelected-1];
666
667 pfdi->hgc=OS2pglCreateContext(hdc,
668 pvc,
669 sharelist,
670 (pfdi->pfd.dwFlags & PFD_DRAW_TO_WINDOW)?TRUE:FALSE);
671
672 return pfdi->hgc;
673 }
674 }
675
676 return NULL;
677}
678
679int WIN32API wglDescribePixelFormat(HDC hdc,
680 GLint iFormat,
681 GLuint nBytes,
682 PIXELFORMATDESCRIPTOR *pfd)
683{
684 if(iFormat<1 || iFormat>global_visual_config_count)
685 iFormat=1; /* Or should we return an error?*/
686
687 if(pfd && nBytes)
688 {
689 PIXELFORMATDESCRIPTOR pfd_use;
690
691 GL_VisualConfig_to_PixelFormat(hdc,global_visual_config_list[iFormat-1],&pfd_use);
692
693#ifdef DEBUG
694 VisCfgDump(global_visual_config_list[iFormat-1]);
695 PixFmtDump(&pfd_use);
696#endif
697
698 memcpy(pfd,&pfd_use,nBytes);
699 }
700
701 return global_visual_config_count;
702}
703
704BOOL WIN32API wglDeleteContext(HGC hgc)
705{
706 PFDINFO *pfdi;
707
708 pfdi=query_pfdi_by_hgc(hgc);
709
710 if(pfdi)
711 return OS2pglDestroyContext(pfdi->hdc,hgc);
712
713 return FALSE;
714}
715
716BOOL WIN32API wglMakeCurrent(HDC hdc,HGC hgc)
717{
718 BOOL rc;
719 HWND hWnd;
720
721 hWnd=Win32ToOS2Handle(WindowFromDC(hdc));
722
723 rc=OS2pglMakeCurrent(hdc,hgc,hWnd);
724
725 return rc;
726}
727
728BOOL WIN32API wglCopyContext(HGC hgc_src,HGC hgc_dst,GLuint attrib_mask)
729{
730 PFDINFO *pfdi;
731
732 pfdi=query_pfdi_by_hgc(hgc_src);
733
734 if(pfdi)
735 return OS2pglCopyContext(pfdi->hdc,hgc_src,hgc_dst,attrib_mask);
736
737 return FALSE;
738}
739
740BOOL WIN32API wglUseFontBitmapsA(HDC hdc,
741 DWORD first,
742 DWORD count,
743 DWORD listbase)
744{
745 /* FIXME: how to map to correct font ?? */
746 int id=0;
747
748 return OS2pglUsePMBitmapFont(hdc,id,first,count,listbase);
749}
750
751BOOL WIN32API wglUseFontBitmapsW(HDC hdc,
752 DWORD first,
753 DWORD count,
754 DWORD listbase)
755{
756 /* FIXME: how to map to correct font ?? */
757 int id=0;
758
759 return OS2pglUsePMBitmapFont(hdc,id,first,count,listbase);
760}
761
762HGC WIN32API wglGetCurrentContext(void)
763{
764 HWND hwnd;
765 PFDINFO *pfdi;
766
767 hwnd=OS2ToWin32Handle(OS2pglGetCurrentWindow(WinQueryAnchorBlock(HWND_DESKTOP)));
768
769 pfdi=query_pfdi_by_hwnd(hwnd);
770
771 if(pfdi)
772 return pfdi->hgc;
773
774 return 0;
775}
776
777HDC WIN32API wglGetCurrentDC(void)
778{
779 HWND hwnd;
780 PFDINFO *pfdi;
781
782 hwnd=OS2ToWin32Handle(OS2pglGetCurrentWindow(WinQueryAnchorBlock(HWND_DESKTOP)));
783
784 pfdi=query_pfdi_by_hwnd(hwnd);
785
786 if(pfdi)
787 return pfdi->hdc;
788
789 return 0;
790}
791
792/****************************************************************************/
793/* */
794/* As of yet unsupported wgl functions */
795/* */
796/****************************************************************************/
797
798GLint WIN32API wglGetLayerPaletteEntries(HDC hdc,
799 GLint iLayerPlane,
800 GLint iStart,
801 GLint cEntries,
802 const COLORREF *pcr)
803{
804 dprintf(("OPENGL32: wglGetLayerPaletteEntries - not implemented\n"));
805 return 0;
806}
807
808BOOL WIN32API wglRealizeLayerPalette(HDC hdc,GLint iLayerPlane,BOOL bRealize)
809{
810 dprintf(("OPENGL32: wglRealizeLayerPalette - not implemented\n"));
811 return FALSE;
812}
813
814BOOL WIN32API wglShareLists(HGC hgc1,HGC hgc2)
815{
816 dprintf(("OPENGL32: wglShareLists - not implemented\n"));
817 return FALSE;
818}
819
820/*BOOL WIN32API wglGetDefaultProcAddress(char *x)
821{
822 dprintf(("OPENGL32: wglGetDefaultProcAddress - not implemented\n"));
823 return FALSE;
824}*/
825
826GLint WIN32API wglSetLayerPaletteEntries(HDC hdc,
827 GLint iLayerPlane,
828 GLint iStart,
829 GLint cEntries,
830 const COLORREF *pcr)
831{
832 dprintf(("OPENGL32: wglSetLayerPaletteEntries - not implemented\n"));
833 return 0;
834}
835
836PFN WIN32API wglGetProcAddress(LPCSTR *lpszProc)
837{
838 dprintf(("OPENGL32: wglGetProcAddress - not implemented\n"));
839 return NULL;
840}
841
842BOOL WIN32API wglUseFontOutlinesA(HDC hdc,
843 DWORD first,
844 DWORD count,
845 DWORD listbase,
846 GLfloat deviation,
847 GLfloat extrusion,
848 GLint format)
849{
850 dprintf(("OPENGL32: wglUseFontOutlinesA - not implemented\n"));
851 return FALSE;
852}
853
854BOOL WIN32API wglUseFontOutlinesW(HDC hdc,
855 DWORD first,
856 DWORD count,
857 DWORD listbase,
858 GLfloat deviation,
859 GLfloat extrusion,
860 GLint format)
861{
862 dprintf(("OPENGL32: wglUseFontOutlinesW - not implemented\n"));
863 return FALSE;
864}
865
866BOOL WIN32API wglSwapLayerBuffers(HDC hdc,GLuint fuPlanes)
867{
868 dprintf(("OPENGL32: wglSwapLayerBuffers - not implemented\n"));
869 return FALSE;
870}
871
872BOOL WIN32API wglDescribeLayerPlane(HDC hdc,
873 GLint iPixelFormat,
874 GLint iLayerPlane,
875 GLuint nBytes,
876 LAYERPLANEDESCRIPTOR *plpd)
877{
878 dprintf(("OPENGL32: wglDescribeLayerPlane - not implemented\n"));
879 return FALSE;
880}
881
882BOOL WIN32API wglCreateLayerContext(HDC hdc,GLint iLayer)
883{
884 dprintf(("OPENGL32: wglCreateLayerContext - not implemented\n"));
885 return FALSE;
886}
887
888/***************************************************************************/
889/* */
890/* gl Conversion functions */
891/* */
892/***************************************************************************/
893
894void WIN32API glAccum(GLenum op,GLfloat value)
895{
896 OS2glAccum(op,value);
897}
898
899void WIN32API glAlphaFunc(GLenum func,GLclampf ref)
900{
901 OS2glAlphaFunc(func,ref);
902}
903
904void WIN32API glBegin(GLenum mode)
905{
906 OS2glBegin(mode);
907}
908
909void WIN32API glBitmap(GLsizei width,
910 GLsizei height,
911 GLfloat xorig,
912 GLfloat yorig,
913 GLfloat xmove,
914 GLfloat ymove,
915 const GLubyte *bitmap)
916{
917 OS2glBitmap(width,height,xorig,yorig,xmove,ymove,bitmap);
918}
919
920void WIN32API glBlendFunc(GLenum sfactor,
921 GLenum dfactor)
922{
923 OS2glBlendFunc(sfactor,dfactor);
924}
925
926void WIN32API glCallList(GLuint list)
927{
928 OS2glCallList(list);
929}
930
931void WIN32API glCallLists(GLsizei n,
932 GLenum type,
933 const GLvoid *lists)
934{
935 OS2glCallLists(n,type,lists);
936}
937
938void WIN32API glClear(GLbitfield mask)
939{
940 OS2glClear(mask);
941}
942
943void WIN32API glClearAccum(GLfloat red,
944 GLfloat green,
945 GLfloat blue,
946 GLfloat alpha)
947{
948 OS2glClearAccum(red,green,blue,alpha);
949}
950
951void WIN32API glClearColor(GLclampf red,
952 GLclampf green,
953 GLclampf blue,
954 GLclampf alpha)
955{
956 OS2glClearColor(red,green,blue,alpha);
957}
958
959void WIN32API glClearDepth(GLclampd depth)
960{
961 OS2glClearDepth(depth);
962}
963
964void WIN32API glClearIndex(GLfloat c)
965{
966 OS2glClearIndex(c);
967}
968
969void WIN32API glClearStencil(GLint s)
970{
971 OS2glClearStencil(s);
972}
973
974void WIN32API glClipPlane(GLenum plane,
975 const GLdouble *equation)
976{
977 OS2glClipPlane(plane,equation);
978}
979
980void WIN32API glColor3b(GLbyte red,
981 GLbyte green,
982 GLbyte blue)
983{
984 OS2glColor3b(red,green,blue);
985}
986
987void WIN32API glColor3bv(const GLbyte *v)
988{
989 OS2glColor3bv(v);
990}
991
992void WIN32API glColor3d(GLdouble red,
993 GLdouble green,
994 GLdouble blue)
995{
996 OS2glColor3d(red,green,blue);
997}
998
999void WIN32API glColor3dv(const GLdouble *v)
1000{
1001 OS2glColor3dv(v);
1002}
1003
1004void WIN32API glColor3f(GLfloat red,
1005 GLfloat green,
1006 GLfloat blue)
1007{
1008 OS2glColor3f(red,green,blue);
1009}
1010
1011void WIN32API glColor3fv(const GLfloat *v)
1012{
1013 OS2glColor3fv(v);
1014}
1015
1016void WIN32API glColor3i(GLint red,
1017 GLint green,
1018 GLint blue)
1019{
1020 OS2glColor3i(red,green,blue);
1021}
1022
1023void WIN32API glColor3iv(const GLint *v)
1024{
1025 OS2glColor3iv(v);
1026}
1027
1028void WIN32API glColor3s(GLshort red,
1029 GLshort green,
1030 GLshort blue)
1031{
1032 OS2glColor3s(red,green,blue);
1033}
1034
1035void WIN32API glColor3sv(const GLshort *v)
1036{
1037 OS2glColor3sv(v);
1038}
1039
1040void WIN32API glColor3ub(GLubyte red,
1041 GLubyte green,
1042 GLubyte blue)
1043{
1044 OS2glColor3ub(red,green,blue);
1045}
1046
1047void WIN32API glColor3ubv(const GLubyte *v)
1048{
1049 OS2glColor3ubv(v);
1050}
1051
1052void WIN32API glColor3ui(GLuint red,
1053 GLuint green,
1054 GLuint blue)
1055{
1056 OS2glColor3ui(red,green,blue);
1057}
1058
1059void WIN32API glColor3uiv(const GLuint *v)
1060{
1061 OS2glColor3uiv(v);
1062}
1063
1064void WIN32API glColor3us(GLushort red,
1065 GLushort green,
1066 GLushort blue)
1067{
1068 OS2glColor3us(red,green,blue);
1069}
1070
1071void WIN32API glColor3usv(const GLushort *v)
1072{
1073 OS2glColor3usv(v);
1074}
1075
1076void WIN32API glColor4b(GLbyte red,
1077 GLbyte green,
1078 GLbyte blue,
1079 GLbyte alpha)
1080{
1081 OS2glColor4b(red,green,blue,alpha);
1082}
1083
1084void WIN32API glColor4bv(const GLbyte *v)
1085{
1086 OS2glColor4bv(v);
1087}
1088
1089void WIN32API glColor4d(GLdouble red,
1090 GLdouble green,
1091 GLdouble blue,
1092 GLdouble alpha)
1093{
1094 OS2glColor4d(red,green,blue,alpha);
1095}
1096
1097void WIN32API glColor4dv(const GLdouble *v)
1098{
1099 OS2glColor4dv(v);
1100}
1101
1102void WIN32API glColor4f(GLfloat red,
1103 GLfloat green,
1104 GLfloat blue,
1105 GLfloat alpha)
1106{
1107 OS2glColor4f(red,green,blue,alpha);
1108}
1109
1110void WIN32API glColor4fv(const GLfloat *v)
1111{
1112 OS2glColor4fv(v);
1113}
1114
1115void WIN32API glColor4i(GLint red,
1116 GLint green,
1117 GLint blue,
1118 GLint alpha)
1119{
1120 OS2glColor4i(red,green,blue,alpha);
1121}
1122
1123void WIN32API glColor4iv(const GLint *v)
1124{
1125 OS2glColor4iv(v);
1126}
1127
1128void WIN32API glColor4s(GLshort red,
1129 GLshort green,
1130 GLshort blue,
1131 GLshort alpha)
1132{
1133 OS2glColor4s(red,green,blue,alpha);
1134}
1135
1136void WIN32API glColor4sv(const GLshort *v)
1137{
1138 OS2glColor4sv(v);
1139}
1140
1141void WIN32API glColor4ub(GLubyte red,
1142 GLubyte green,
1143 GLubyte blue,
1144 GLubyte alpha)
1145{
1146 OS2glColor4ub(red,green,blue,alpha);
1147}
1148
1149void WIN32API glColor4ubv(const GLubyte *v)
1150{
1151 OS2glColor4ubv(v);
1152}
1153
1154void WIN32API glColor4ui(GLuint red,
1155 GLuint green,
1156 GLuint blue,
1157 GLuint alpha)
1158{
1159 OS2glColor4ui(red,green,blue,alpha);
1160}
1161
1162void WIN32API glColor4uiv(const GLuint *v)
1163{
1164 OS2glColor4uiv(v);
1165}
1166
1167void WIN32API glColor4us(GLushort red,
1168 GLushort green,
1169 GLushort blue,
1170 GLushort alpha)
1171{
1172 OS2glColor4us(red,green,blue,alpha);
1173}
1174
1175void WIN32API glColor4usv(const GLushort *v)
1176{
1177 OS2glColor4usv(v);
1178}
1179
1180void WIN32API glColorMask(GLboolean red,
1181 GLboolean green,
1182 GLboolean blue,
1183 GLboolean alpha)
1184{
1185 OS2glColorMask(red,green,blue,alpha);
1186}
1187
1188void WIN32API glColorMaterial(GLenum face,
1189 GLenum mode)
1190{
1191 OS2glColorMaterial(face,mode);
1192}
1193
1194void WIN32API glCopyPixels(GLint x,
1195 GLint y,
1196 GLsizei width,
1197 GLsizei height,
1198 GLenum type)
1199{
1200 OS2glCopyPixels(x,y,width,height,type);
1201}
1202
1203void WIN32API glCullFace(GLenum mode)
1204{
1205 OS2glCullFace(mode);
1206}
1207
1208void WIN32API glDeleteLists(GLuint list,
1209 GLsizei range)
1210{
1211 OS2glDeleteLists(list,range);
1212}
1213
1214void WIN32API glDepthFunc(GLenum func)
1215{
1216 OS2glDepthFunc(func);
1217}
1218
1219void WIN32API glDepthMask(GLboolean flag)
1220{
1221 OS2glDepthMask(flag);
1222}
1223
1224void WIN32API glDepthRange(GLclampd near,
1225 GLclampd far)
1226{
1227 OS2glDepthRange(near,far);
1228}
1229
1230void WIN32API glDisable(GLenum cap)
1231{
1232 OS2glDisable(cap);
1233}
1234
1235void WIN32API glDrawBuffer(GLenum mode)
1236{
1237 OS2glDrawBuffer(mode);
1238}
1239
1240void WIN32API glDrawPixels(GLsizei width,
1241 GLsizei height,
1242 GLenum format,
1243 GLenum type,
1244 const GLvoid *pixels)
1245{
1246 OS2glDrawPixels(width,height,format,type,pixels);
1247}
1248
1249void WIN32API glEdgeFlag(GLboolean flag)
1250{
1251 OS2glEdgeFlag(flag);
1252}
1253
1254void WIN32API glEdgeFlagv(const GLboolean *flag)
1255{
1256 OS2glEdgeFlagv(flag);
1257}
1258
1259void WIN32API glEnable(GLenum cap)
1260{
1261 OS2glEnable(cap);
1262}
1263
1264void WIN32API glEnd(void)
1265{
1266 OS2glEnd();
1267}
1268
1269void WIN32API glEndList(void)
1270{
1271 OS2glEndList();
1272}
1273
1274void WIN32API glEvalCoord1d(GLdouble u)
1275{
1276 OS2glEvalCoord1d(u);
1277}
1278
1279void WIN32API glEvalCoord1dv(const GLdouble *u)
1280{
1281 OS2glEvalCoord1dv(u);
1282}
1283
1284void WIN32API glEvalCoord1f(GLfloat u)
1285{
1286 OS2glEvalCoord1f(u);
1287}
1288
1289void WIN32API glEvalCoord1fv(const GLfloat *u)
1290{
1291 OS2glEvalCoord1fv(u);
1292}
1293
1294void WIN32API glEvalCoord2d(GLdouble u,
1295 GLdouble v)
1296{
1297 OS2glEvalCoord2d(u,v);
1298}
1299
1300void WIN32API glEvalCoord2dv(const GLdouble *u)
1301{
1302 OS2glEvalCoord2dv(u);
1303}
1304
1305void WIN32API glEvalCoord2f(GLfloat u,
1306 GLfloat v)
1307{
1308 OS2glEvalCoord2f(u,v);
1309}
1310
1311void WIN32API glEvalCoord2fv(const GLfloat *u)
1312{
1313 OS2glEvalCoord2fv(u);
1314}
1315
1316void WIN32API glEvalMesh1(GLenum mode,
1317 GLint i1,
1318 GLint i2)
1319{
1320 OS2glEvalMesh1(mode,i1,i2);
1321}
1322
1323void WIN32API glEvalMesh2(GLenum mode,
1324 GLint i1,
1325 GLint i2,
1326 GLint j1,
1327 GLint j2)
1328{
1329 OS2glEvalMesh2(mode,i1,i2,j1,j2);
1330}
1331
1332void WIN32API glEvalPoint1(GLint i)
1333{
1334 OS2glEvalPoint1(i);
1335}
1336
1337void WIN32API glEvalPoint2(GLint i,
1338 GLint j)
1339{
1340 OS2glEvalPoint2(i,j);
1341}
1342
1343void WIN32API glFeedbackBuffer(GLsizei size,
1344 GLenum type,
1345 GLfloat *buffer)
1346{
1347 OS2glFeedbackBuffer(size,type,buffer);
1348}
1349
1350void WIN32API glFinish(void)
1351{
1352 OS2glFinish();
1353}
1354
1355void WIN32API glFlush(void)
1356{
1357 OS2glFlush();
1358
1359 dprintf(("OPENGL32: glFlush() complete\n"));
1360}
1361
1362void WIN32API glFogf(GLenum pname,
1363 GLfloat param)
1364{
1365 OS2glFogf(pname,param);
1366}
1367
1368void WIN32API glFogfv(GLenum pname,
1369 const GLfloat *params)
1370{
1371 OS2glFogfv(pname,params);
1372}
1373
1374void WIN32API glFogi(GLenum pname,
1375 GLint param)
1376{
1377 OS2glFogi(pname,param);
1378}
1379
1380void WIN32API glFogiv(GLenum pname,
1381 const GLint *params)
1382{
1383 OS2glFogiv(pname,params);
1384}
1385
1386void WIN32API glFrontFace(GLenum mode)
1387{
1388 OS2glFrontFace(mode);
1389}
1390
1391void WIN32API glFrustum(GLdouble left,
1392 GLdouble right,
1393 GLdouble bottom,
1394 GLdouble top,
1395 GLdouble near,
1396 GLdouble far)
1397{
1398 OS2glFrustum(left,right,bottom,top,near,far);
1399}
1400
1401GLuint WIN32API glGenLists(GLsizei range)
1402{
1403 return OS2glGenLists(range);
1404}
1405
1406void WIN32API glGetBooleanv(GLenum pname,
1407 GLboolean *params)
1408{
1409 OS2glGetBooleanv(pname,params);
1410}
1411
1412void WIN32API glGetClipPlane(GLenum plane,
1413 GLdouble *equation)
1414{
1415 OS2glGetClipPlane(plane,equation);
1416}
1417
1418void WIN32API glGetDoublev(GLenum pname,
1419 GLdouble *params)
1420{
1421 OS2glGetDoublev(pname,params);
1422}
1423
1424GLenum WIN32API glGetError(void)
1425{
1426 return OS2glGetError();
1427}
1428
1429void WIN32API glGetFloatv(GLenum pname,
1430 GLfloat *params)
1431{
1432 OS2glGetFloatv(pname,params);
1433}
1434
1435void WIN32API glGetIntegerv(GLenum pname,
1436 GLint *params)
1437{
1438 OS2glGetIntegerv(pname,params);
1439}
1440
1441void WIN32API glGetLightfv(GLenum light,
1442 GLenum pname,
1443 GLfloat *params)
1444{
1445 OS2glGetLightfv(light,pname,params);
1446}
1447
1448void WIN32API glGetLightiv(GLenum light,
1449 GLenum pname,
1450 GLint *params)
1451{
1452 OS2glGetLightiv(light,pname,params);
1453}
1454
1455void WIN32API glGetMapdv(GLenum target,
1456 GLenum query,
1457 GLdouble *v)
1458{
1459 OS2glGetMapdv(target,query,v);
1460}
1461
1462void WIN32API glGetMapfv(GLenum target,
1463 GLenum query,
1464 GLfloat *v)
1465{
1466 OS2glGetMapfv(target,query,v);
1467}
1468
1469void WIN32API glGetMapiv(GLenum target,
1470 GLenum query,
1471 GLint *v)
1472{
1473 OS2glGetMapiv(target,query,v);
1474}
1475
1476void WIN32API glGetMaterialfv(GLenum face,
1477 GLenum pname,
1478 GLfloat *params)
1479{
1480 OS2glGetMaterialfv(face,pname,params);
1481}
1482
1483void WIN32API glGetMaterialiv(GLenum face,
1484 GLenum pname,
1485 GLint *params)
1486{
1487 OS2glGetMaterialiv(face,pname,params);
1488}
1489
1490void WIN32API glGetPixelMapfv(GLenum map,
1491 GLfloat *values)
1492{
1493 OS2glGetPixelMapfv(map,values);
1494}
1495
1496void WIN32API glGetPixelMapuiv(GLenum map,
1497 GLuint *values)
1498{
1499 OS2glGetPixelMapuiv(map,values);
1500}
1501
1502void WIN32API glGetPixelMapusv(GLenum map,
1503 GLushort *values)
1504{
1505 OS2glGetPixelMapusv(map,values);
1506}
1507
1508void WIN32API glGetPolygonStipple(GLubyte *mask)
1509{
1510 OS2glGetPolygonStipple(mask);
1511}
1512
1513const GLubyte * WIN32API glGetString(GLenum name)
1514{
1515 return OS2glGetString(name);
1516}
1517
1518void WIN32API glGetTexEnvfv(GLenum target,
1519 GLenum pname,
1520 GLfloat *params)
1521{
1522 OS2glGetTexEnvfv(target,pname,params);
1523}
1524
1525void WIN32API glGetTexEnviv(GLenum target,
1526 GLenum pname,
1527 GLint *params)
1528{
1529 OS2glGetTexEnviv(target,pname,params);
1530}
1531
1532void WIN32API glGetTexGendv(GLenum coord,
1533 GLenum pname,
1534 GLdouble *params)
1535{
1536 OS2glGetTexGendv(coord,pname,params);
1537}
1538
1539void WIN32API glGetTexGenfv(GLenum coord,
1540 GLenum pname,
1541 GLfloat *params)
1542{
1543 OS2glGetTexGenfv(coord,pname,params);
1544}
1545
1546void WIN32API glGetTexGeniv(GLenum coord,
1547 GLenum pname,
1548 GLint *params)
1549{
1550 OS2glGetTexGeniv(coord,pname,params);
1551}
1552
1553void WIN32API glGetTexImage(GLenum target,
1554 GLint level,
1555 GLenum format,
1556 GLenum type,
1557 GLvoid *pixels)
1558{
1559 OS2glGetTexImage(target,level,format,type,pixels);
1560}
1561
1562void WIN32API glGetTexLevelParameterfv(GLenum target,
1563 GLint level,
1564 GLenum pname,
1565 GLfloat *params)
1566{
1567 OS2glGetTexLevelParameterfv(target,level,pname,params);
1568}
1569
1570void WIN32API glGetTexLevelParameteriv(GLenum target,
1571 GLint level,
1572 GLenum pname,
1573 GLint *params)
1574{
1575 OS2glGetTexLevelParameteriv(target,level,pname,params);
1576}
1577
1578void WIN32API glGetTexParameterfv(GLenum target,
1579 GLenum pname,
1580 GLfloat *params)
1581{
1582 OS2glGetTexParameterfv(target,pname,params);
1583}
1584
1585void WIN32API glGetTexParameteriv(GLenum target,
1586 GLenum pname,
1587 GLint *params)
1588{
1589 OS2glGetTexParameteriv(target,pname,params);
1590}
1591
1592void WIN32API glHint(GLenum target,
1593 GLenum mod)
1594{
1595 OS2glHint(target,mod);
1596}
1597
1598void WIN32API glIndexMask(GLuint mask)
1599{
1600 OS2glIndexMask(mask);
1601}
1602
1603void WIN32API glIndexd(GLdouble c)
1604{
1605 OS2glIndexd(c);
1606}
1607
1608void WIN32API glIndexdv(const GLdouble *c)
1609{
1610 OS2glIndexdv(c);
1611}
1612
1613void WIN32API glIndexf(GLfloat c)
1614{
1615 OS2glIndexf(c);
1616}
1617
1618void WIN32API glIndexfv(const GLfloat *c)
1619{
1620 OS2glIndexfv(c);
1621}
1622
1623void WIN32API glIndexi(GLint c)
1624{
1625 OS2glIndexi(c);
1626}
1627
1628void WIN32API glIndexiv(const GLint *c)
1629{
1630 OS2glIndexiv(c);
1631}
1632
1633void WIN32API glIndexs(GLshort c)
1634{
1635 OS2glIndexs(c);
1636}
1637
1638void WIN32API glIndexsv(const GLshort *c)
1639{
1640 OS2glIndexsv(c);
1641}
1642
1643void WIN32API glInitNames(void)
1644{
1645 OS2glInitNames();
1646}
1647
1648GLboolean WIN32API glIsEnabled(GLenum cap)
1649{
1650 return OS2glIsEnabled(cap);
1651}
1652
1653GLboolean WIN32API glIsList(GLuint list)
1654{
1655 return OS2glIsList(list);
1656}
1657
1658void WIN32API glLightModelf(GLenum pname,
1659 GLfloat param)
1660{
1661 OS2glLightModelf(pname,param);
1662}
1663
1664void WIN32API glLightModelfv(GLenum pname,
1665 const GLfloat *params)
1666{
1667 OS2glLightModelfv(pname,params);
1668}
1669
1670void WIN32API glLightModeli(GLenum pname,
1671 GLint param)
1672{
1673 OS2glLightModeli(pname,param);
1674}
1675
1676void WIN32API glLightModeliv(GLenum pname,
1677 const GLint *params)
1678{
1679 OS2glLightModeliv(pname,params);
1680}
1681
1682void WIN32API glLightf(GLenum light,
1683 GLenum pname,
1684 GLfloat param)
1685{
1686 OS2glLightf(light,pname,param);
1687}
1688
1689void WIN32API glLightfv(GLenum light,
1690 GLenum pname,
1691 const GLfloat *params)
1692{
1693 OS2glLightfv(light,pname,params);
1694}
1695
1696void WIN32API glLighti(GLenum light,
1697 GLenum pname,
1698 GLint param)
1699{
1700 OS2glLighti(light,pname,param);
1701}
1702
1703void WIN32API glLightiv(GLenum light,
1704 GLenum pname,
1705 const GLint *params)
1706{
1707 OS2glLightiv(light,pname,params);
1708}
1709
1710void WIN32API glLineStipple(GLint factor,
1711 GLushort pattern)
1712{
1713 OS2glLineStipple(factor,pattern);
1714}
1715
1716void WIN32API glLineWidth(GLfloat width)
1717{
1718 OS2glLineWidth(width);
1719}
1720
1721void WIN32API glListBase(GLuint base)
1722{
1723 OS2glListBase(base);
1724}
1725
1726void WIN32API glLoadIdentity(void)
1727{
1728 OS2glLoadIdentity();
1729}
1730
1731void WIN32API glLoadMatrixd(GLdouble *m)
1732{
1733 OS2glLoadMatrixd(m);
1734}
1735
1736void WIN32API glLoadMatrixf(GLfloat *m)
1737{
1738 OS2glLoadMatrixf(m);
1739}
1740
1741void WIN32API glLoadName(GLuint name)
1742{
1743 OS2glLoadName(name);
1744}
1745
1746void WIN32API glLogicOp(GLenum opcode)
1747{
1748 OS2glLogicOp(opcode);
1749}
1750
1751void WIN32API glMap1d(GLenum target,
1752 GLdouble u1,
1753 GLdouble u2,
1754 GLint stride,
1755 GLint order,
1756 const GLdouble *points)
1757{
1758 OS2glMap1d(target,u1,u2,stride,order,points);
1759}
1760
1761void WIN32API glMap1f(GLenum target,
1762 GLfloat u1,
1763 GLfloat u2,
1764 GLint stride,
1765 GLint order,
1766 const GLfloat *points)
1767{
1768 OS2glMap1f(target,u1,u2,stride,order,points);
1769}
1770
1771void WIN32API glMap2d(GLenum target,
1772 GLdouble u1,
1773 GLdouble u2,
1774 GLint ustride,
1775 GLint uorder,
1776 GLdouble v1,
1777 GLdouble v2,
1778 GLint vstride,
1779 GLint vorder,
1780 const GLdouble *points)
1781{
1782 OS2glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points);
1783}
1784
1785void WIN32API glMap2f(GLenum target,
1786 GLfloat u1,
1787 GLfloat u2,
1788 GLint ustride,
1789 GLint uorder,
1790 GLfloat v1,
1791 GLfloat v2,
1792 GLint vstride,
1793 GLint vorder,
1794 const GLfloat *points)
1795{
1796 OS2glMap2f(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points);
1797}
1798
1799void WIN32API glMapGrid1d(GLint un,
1800 GLdouble u1,
1801 GLdouble u2)
1802{
1803 OS2glMapGrid1d(un,u1,u2);
1804}
1805
1806void WIN32API glMapGrid1f(GLint un,
1807 GLfloat u1,
1808 GLfloat u2)
1809{
1810 OS2glMapGrid1f(un,u1,u2);
1811}
1812
1813void WIN32API glMapGrid2d(GLint un,
1814 GLdouble u1,
1815 GLdouble u2,
1816 GLint uv,
1817 GLdouble v1,
1818 GLdouble v2)
1819{
1820 OS2glMapGrid2d(un,u1,u2,uv,v1,v2);
1821}
1822
1823void WIN32API glMapGrid2f(GLint un,
1824 GLfloat u1,
1825 GLfloat u2,
1826 GLint uv,
1827 GLfloat v1,
1828 GLfloat v2)
1829{
1830 OS2glMapGrid2f(un,u1,u2,uv,v1,v2);
1831}
1832
1833void WIN32API glMaterialf(GLenum face,
1834 GLenum pname,
1835 GLfloat param)
1836{
1837 OS2glMaterialf(face,pname,param);
1838}
1839
1840void WIN32API glMaterialfv(GLenum face,
1841 GLenum pname,
1842 const GLfloat *params)
1843{
1844 OS2glMaterialfv(face,pname,params);
1845}
1846
1847void WIN32API glMateriali(GLenum face,
1848 GLenum pname,
1849 GLint param)
1850{
1851 OS2glMateriali(face,pname,param);
1852}
1853
1854void WIN32API glMaterialiv(GLenum face,
1855 GLenum pname,
1856 const GLint *params)
1857{
1858 OS2glMaterialiv(face,pname,params);
1859}
1860
1861void WIN32API glMatrixMode(GLenum mode)
1862{
1863 OS2glMatrixMode(mode);
1864}
1865
1866void WIN32API glMultMatrixd(const GLdouble *m)
1867{
1868 OS2glMultMatrixd(m);
1869}
1870
1871void WIN32API glMultMatrixf(const GLfloat *m)
1872{
1873 OS2glMultMatrixf(m);
1874}
1875
1876void WIN32API glNewList(GLuint list,
1877 GLenum mode)
1878{
1879 OS2glNewList(list,mode);
1880}
1881
1882void WIN32API glNormal3b(GLbyte nx,
1883 GLbyte ny,
1884 GLbyte nz)
1885{
1886 OS2glNormal3b(nx,ny,nz);
1887}
1888
1889void WIN32API glNormal3bv(const GLbyte *v)
1890{
1891 OS2glNormal3bv(v);
1892}
1893
1894void WIN32API glNormal3d(GLdouble nx,
1895 GLdouble ny,
1896 GLdouble nz)
1897{
1898 OS2glNormal3d(nx,ny,nz);
1899}
1900
1901void WIN32API glNormal3dv(const GLdouble *v)
1902{
1903 OS2glNormal3dv(v);
1904}
1905
1906void WIN32API glNormal3f(GLfloat nx,
1907 GLfloat ny,
1908 GLfloat nz)
1909{
1910 OS2glNormal3f(nx,ny,nz);
1911}
1912
1913void WIN32API glNormal3fv(const GLfloat *v)
1914{
1915 OS2glNormal3fv(v);
1916}
1917
1918void WIN32API glNormal3i(GLint nx,
1919 GLint ny,
1920 GLint nz)
1921{
1922 OS2glNormal3i(nx,ny,nz);
1923}
1924
1925void WIN32API glNormal3iv(const GLint *v)
1926{
1927 OS2glNormal3iv(v);
1928}
1929
1930void WIN32API glNormal3s(GLshort nx,
1931 GLshort ny,
1932 GLshort nz)
1933{
1934 OS2glNormal3s(nx,ny,nz);
1935}
1936
1937void WIN32API glNormal3sv(const GLshort *v)
1938{
1939 OS2glNormal3sv(v);
1940}
1941
1942void WIN32API glOrtho(GLdouble left,
1943 GLdouble right,
1944 GLdouble bottom,
1945 GLdouble top,
1946 GLdouble near,
1947 GLdouble far)
1948{
1949 OS2glOrtho(left,right,bottom,top,near,far);
1950}
1951
1952void WIN32API glPassThrough(GLfloat token)
1953{
1954 OS2glPassThrough(token);
1955}
1956
1957void WIN32API glPixelMapfv(GLenum map,
1958 GLint mapsize,
1959 const GLfloat *values)
1960{
1961 OS2glPixelMapfv(map,mapsize,values);
1962}
1963
1964void WIN32API glPixelMapuiv(GLenum map,
1965 GLint mapsize,
1966 const GLuint *values)
1967{
1968 OS2glPixelMapuiv(map,mapsize,values);
1969}
1970
1971void WIN32API glPixelMapusv(GLenum map,
1972 GLint mapsize,
1973 const GLushort *values)
1974{
1975 OS2glPixelMapusv(map,mapsize,values);
1976}
1977
1978void WIN32API glPixelStoref(GLenum pname,
1979 GLfloat param)
1980{
1981 OS2glPixelStoref(pname,param);
1982}
1983
1984void WIN32API glPixelStorei(GLenum pname,
1985 GLint param)
1986{
1987 OS2glPixelStorei(pname,param);
1988}
1989
1990void WIN32API glPixelTransferf(GLenum pname,
1991 GLfloat param)
1992{
1993 OS2glPixelTransferf(pname,param);
1994}
1995
1996void WIN32API glPixelTransferi(GLenum pname,
1997 GLint param)
1998{
1999 OS2glPixelTransferi(pname,param);
2000}
2001
2002void WIN32API glPixelZoom(GLfloat xfactor,
2003 GLfloat yfactor)
2004{
2005 OS2glPixelZoom(xfactor,yfactor);
2006}
2007
2008void WIN32API glPointSize(GLfloat size)
2009{
2010 OS2glPointSize(size);
2011}
2012
2013void WIN32API glPolygonMode(GLenum face,
2014 GLenum mode)
2015{
2016 OS2glPolygonMode(face,mode);
2017}
2018
2019void WIN32API glPolygonStipple(const GLubyte *mask)
2020{
2021 OS2glPolygonStipple(mask);
2022}
2023
2024void WIN32API glPopAttrib(void)
2025{
2026 OS2glPopAttrib();
2027}
2028
2029void WIN32API glPopMatrix (void)
2030{
2031 OS2glPopMatrix();
2032}
2033
2034void WIN32API glPopName(void)
2035{
2036 OS2glPopName();
2037}
2038
2039void WIN32API glPushAttrib(GLbitfield mask)
2040{
2041 OS2glPushAttrib(mask);
2042}
2043
2044void WIN32API glPushMatrix(void)
2045{
2046 OS2glPushMatrix();
2047}
2048
2049void WIN32API glPushName(GLuint name)
2050{
2051 OS2glPushName(name);
2052}
2053
2054void WIN32API glRasterPos2d(GLdouble x,
2055 GLdouble y)
2056{
2057 OS2glRasterPos2d(x,y);
2058}
2059
2060void WIN32API glRasterPos2dv(const GLdouble *v)
2061{
2062 OS2glRasterPos2dv(v);
2063}
2064void WIN32API glRasterPos2f(GLfloat x,
2065 GLfloat y)
2066{
2067 OS2glRasterPos2f(x,y);
2068}
2069
2070void WIN32API glRasterPos2fv(const GLfloat *v)
2071{
2072 OS2glRasterPos2fv(v);
2073}
2074
2075void WIN32API glRasterPos2i(GLint x,
2076 GLint y)
2077{
2078 OS2glRasterPos2i(x,y);
2079}
2080
2081void WIN32API glRasterPos2iv(const GLint *v)
2082{
2083 OS2glRasterPos2iv(v);
2084}
2085
2086void WIN32API glRasterPos2s(GLshort x,
2087 GLshort y)
2088{
2089 OS2glRasterPos2s(x,y);
2090}
2091
2092void WIN32API glRasterPos2sv(const GLshort *v)
2093{
2094 OS2glRasterPos2sv(v);
2095}
2096
2097void WIN32API glRasterPos3d(GLdouble x,
2098 GLdouble y,
2099 GLdouble z)
2100{
2101 OS2glRasterPos3d(x,y,z);
2102}
2103
2104void WIN32API glRasterPos3dv(const GLdouble *v)
2105{
2106 OS2glRasterPos3dv(v);
2107}
2108
2109void WIN32API glRasterPos3f(GLfloat x,
2110 GLfloat y,
2111 GLfloat z)
2112{
2113 OS2glRasterPos3f(x,y,z);
2114}
2115
2116void WIN32API glRasterPos3fv(const GLfloat *v)
2117{
2118 OS2glRasterPos3fv(v);
2119}
2120
2121void WIN32API glRasterPos3i(GLint x,
2122 GLint y,
2123 GLint z)
2124{
2125 OS2glRasterPos3i(x,y,z);
2126}
2127
2128void WIN32API glRasterPos3iv(const GLint *v)
2129{
2130 OS2glRasterPos3iv(v);
2131}
2132
2133void WIN32API glRasterPos3s(GLshort x,
2134 GLshort y,
2135 GLshort z)
2136{
2137 OS2glRasterPos3s(x,y,z);
2138}
2139
2140void WIN32API glRasterPos3sv(const GLshort *v)
2141{
2142 OS2glRasterPos3sv(v);
2143}
2144
2145void WIN32API glRasterPos4d(GLdouble x,
2146 GLdouble y,
2147 GLdouble z,
2148 GLdouble w)
2149{
2150 OS2glRasterPos4d(x,y,z,w);
2151}
2152
2153void WIN32API glRasterPos4dv(const GLdouble *v)
2154{
2155 OS2glRasterPos4dv(v);
2156}
2157
2158void WIN32API glRasterPos4f(GLfloat x,
2159 GLfloat y,
2160 GLfloat z,
2161 GLfloat w)
2162{
2163 OS2glRasterPos4f(x,y,z,w);
2164}
2165
2166void WIN32API glRasterPos4fv(const GLfloat *v)
2167{
2168 OS2glRasterPos4fv(v);
2169}
2170
2171void WIN32API glRasterPos4i(GLint x,
2172 GLint y,
2173 GLint z,
2174 GLint w)
2175{
2176 OS2glRasterPos4i(x,y,z,w);
2177}
2178
2179void WIN32API glRasterPos4iv(const GLint *v)
2180{
2181 OS2glRasterPos4iv(v);
2182}
2183
2184void WIN32API glRasterPos4s(GLshort x,
2185 GLshort y,
2186 GLshort z,
2187 GLshort w)
2188{
2189 OS2glRasterPos4s(x,y,z,w);
2190}
2191
2192void WIN32API glRasterPos4sv(const GLshort *v)
2193{
2194 OS2glRasterPos4sv(v);
2195}
2196
2197void WIN32API glReadBuffer(GLenum mode)
2198{
2199 OS2glReadBuffer(mode);
2200}
2201
2202void WIN32API glReadPixels(GLint x,
2203 GLint y,
2204 GLsizei width,
2205 GLsizei height,
2206 GLenum format,
2207 GLenum type,
2208 GLvoid *pixels)
2209{
2210 OS2glReadPixels(x,y,width,height,format,type,pixels);
2211}
2212
2213void WIN32API glRectd(GLdouble x1,
2214 GLdouble y1,
2215 GLdouble x2,
2216 GLdouble y2)
2217{
2218 OS2glRectd(x1,y1,x2,y2);
2219}
2220
2221void WIN32API glRectdv(const GLdouble *v1,
2222 const GLdouble *v2)
2223{
2224 OS2glRectdv(v1,v2);
2225}
2226
2227void WIN32API glRectf(GLfloat x1,
2228 GLfloat y1,
2229 GLfloat x2,
2230 GLfloat y2)
2231{
2232 OS2glRectf(x1,y1,x2,y2);
2233}
2234
2235void WIN32API glRectfv(const GLfloat *v1,
2236 const GLfloat *v2)
2237{
2238 OS2glRectfv(v1,v2);
2239}
2240
2241void WIN32API glRecti(GLint x1,
2242 GLint y1,
2243 GLint x2,
2244 GLint y2)
2245{
2246 OS2glRecti(x1,y1,x2,y2);
2247}
2248
2249void WIN32API glRectiv(const GLint *v1,
2250 const GLint *v2)
2251{
2252 OS2glRectiv(v1,v2);
2253}
2254
2255void WIN32API glRects(GLshort x1,
2256 GLshort y1,
2257 GLshort x2,
2258 GLshort y2)
2259{
2260 OS2glRects(x1,y1,x2,y2);
2261}
2262
2263void WIN32API glRectsv(const GLshort *v1,
2264 const GLshort *v2)
2265{
2266 OS2glRectsv(v1,v2);
2267}
2268
2269GLint WIN32API glRenderMode(GLenum mode)
2270{
2271 return OS2glRenderMode(mode);
2272}
2273
2274void WIN32API glRotated(GLdouble angle,
2275 GLdouble x,
2276 GLdouble y,
2277 GLdouble z)
2278{
2279 OS2glRotated(angle,x,y,z);
2280}
2281
2282void WIN32API glRotatef(GLfloat angle,
2283 GLfloat x,
2284 GLfloat y,
2285 GLfloat z)
2286{
2287 OS2glRotatef(angle,x,y,z);
2288}
2289
2290void WIN32API glScaled(GLdouble x,
2291 GLdouble y,
2292 GLdouble z)
2293{
2294 OS2glScaled(x,y,z);
2295}
2296
2297void WIN32API glScalef(GLfloat x,
2298 GLfloat y,
2299 GLfloat z)
2300{
2301 OS2glScalef(x,y,z);
2302}
2303
2304void WIN32API glScissor(GLint x,
2305 GLint y,
2306 GLsizei width,
2307 GLsizei height)
2308{
2309 OS2glScissor(x,y,width,height);
2310}
2311
2312void WIN32API glSelectBuffer(GLsizei size,
2313 GLuint *buffer)
2314{
2315 OS2glSelectBuffer(size,buffer);
2316}
2317
2318void WIN32API glShadeModel(GLenum mode)
2319{
2320 OS2glShadeModel(mode);
2321}
2322
2323void WIN32API glStencilFunc(GLenum func,
2324 GLint ref,
2325 GLuint mask)
2326{
2327 OS2glStencilFunc(func,ref,mask);
2328}
2329
2330void WIN32API glStencilMask(GLuint mask)
2331{
2332 OS2glStencilMask(mask);
2333}
2334
2335void WIN32API glStencilOp(GLenum fail,
2336 GLenum zfail,
2337 GLenum zpass)
2338{
2339 OS2glStencilOp(fail,zfail,zpass);
2340}
2341
2342void WIN32API glTexCoord1d(GLdouble s)
2343{
2344 OS2glTexCoord1d(s);
2345}
2346
2347void WIN32API glTexCoord1dv(const GLdouble *v)
2348{
2349 OS2glTexCoord1dv(v);
2350}
2351
2352void WIN32API glTexCoord1f(GLfloat s)
2353{
2354 OS2glTexCoord1f(s);
2355}
2356
2357void WIN32API glTexCoord1fv(const GLfloat *v)
2358{
2359 OS2glTexCoord1fv(v);
2360}
2361
2362void WIN32API glTexCoord1i(GLint s)
2363{
2364 OS2glTexCoord1i(s);
2365}
2366
2367void WIN32API glTexCoord1iv(const GLint *v)
2368{
2369 OS2glTexCoord1iv(v);
2370}
2371
2372void WIN32API glTexCoord1s(GLshort s)
2373{
2374 OS2glTexCoord1s(s);
2375}
2376
2377void WIN32API glTexCoord1sv(const GLshort *v)
2378{
2379 OS2glTexCoord1sv(v);
2380}
2381
2382void WIN32API glTexCoord2d(GLdouble s,
2383 GLdouble t)
2384{
2385 OS2glTexCoord2d(s,t);
2386}
2387
2388void WIN32API glTexCoord2dv(const GLdouble *v)
2389{
2390 OS2glTexCoord2dv(v);
2391}
2392
2393void WIN32API glTexCoord2f(GLfloat s,
2394 GLfloat t)
2395{
2396 OS2glTexCoord2f(s,t);
2397}
2398
2399void WIN32API glTexCoord2fv(const GLfloat *v)
2400{
2401 OS2glTexCoord2fv(v);
2402}
2403
2404void WIN32API glTexCoord2i(GLint s,
2405 GLint t)
2406{
2407 OS2glTexCoord2i(s,t);
2408}
2409
2410void WIN32API glTexCoord2iv(const GLint *v)
2411{
2412 OS2glTexCoord2iv(v);
2413}
2414
2415void WIN32API glTexCoord2s(GLshort s,
2416 GLshort t)
2417{
2418 OS2glTexCoord2s(s,t);
2419}
2420
2421void WIN32API glTexCoord2sv(const GLshort *v)
2422{
2423 OS2glTexCoord2sv(v);
2424}
2425
2426void WIN32API glTexCoord3d(GLdouble s,
2427 GLdouble t,
2428 GLdouble r)
2429{
2430 OS2glTexCoord3d(s,t,r);
2431}
2432
2433void WIN32API glTexCoord3dv(const GLdouble *v)
2434{
2435 OS2glTexCoord3dv(v);
2436}
2437
2438void WIN32API glTexCoord3f(GLfloat s,
2439 GLfloat t,
2440 GLfloat r)
2441{
2442 OS2glTexCoord3f(s,t,r);
2443}
2444
2445void WIN32API glTexCoord3fv(const GLfloat *v)
2446{
2447 OS2glTexCoord3fv(v);
2448}
2449
2450void WIN32API glTexCoord3i(GLint s,
2451 GLint t,
2452 GLint r)
2453{
2454 OS2glTexCoord3i(s,t,r);
2455}
2456
2457void WIN32API glTexCoord3iv(const GLint *v)
2458{
2459 OS2glTexCoord3iv(v);
2460}
2461
2462void WIN32API glTexCoord3s(GLshort s,
2463 GLshort t,
2464 GLshort r)
2465{
2466 OS2glTexCoord3s(s,t,r);
2467}
2468
2469void WIN32API glTexCoord3sv(const GLshort *v)
2470{
2471 OS2glTexCoord3sv(v);
2472}
2473
2474void WIN32API glTexCoord4d(GLdouble s,
2475 GLdouble t,
2476 GLdouble r,
2477 GLdouble q)
2478{
2479 OS2glTexCoord4d(s,t,r,q);
2480}
2481
2482void WIN32API glTexCoord4dv(const GLdouble *v)
2483{
2484 OS2glTexCoord4dv(v);
2485}
2486
2487void WIN32API glTexCoord4f(GLfloat s,
2488 GLfloat t,
2489 GLfloat r,
2490 GLfloat q)
2491{
2492 OS2glTexCoord4f(s,t,r,q);
2493}
2494
2495void WIN32API glTexCoord4fv(const GLfloat *v)
2496{
2497 OS2glTexCoord4fv(v);
2498}
2499
2500void WIN32API glTexCoord4i(GLint s,
2501 GLint t,
2502 GLint r,
2503 GLint q)
2504{
2505 OS2glTexCoord4i(s,t,r,q);
2506}
2507
2508void WIN32API glTexCoord4iv(const GLint *v)
2509{
2510 OS2glTexCoord4iv(v);
2511}
2512
2513void WIN32API glTexCoord4s(GLshort s,
2514 GLshort t,
2515 GLshort r,
2516 GLshort q)
2517{
2518 OS2glTexCoord4s(s,t,r,q);
2519}
2520
2521void WIN32API glTexCoord4sv(const GLshort *v)
2522{
2523 OS2glTexCoord4sv(v);
2524}
2525
2526void WIN32API glTexEnvf(GLenum target,
2527 GLenum pname,
2528 GLfloat param)
2529{
2530 OS2glTexEnvf(target,pname,param);
2531}
2532
2533void WIN32API glTexEnvfv(GLenum target,
2534 GLenum pname,
2535 const GLfloat *params)
2536{
2537 OS2glTexEnvfv(target,pname,params);
2538}
2539
2540void WIN32API glTexEnvi(GLenum target,
2541 GLenum pname,
2542 GLint param)
2543{
2544 OS2glTexEnvi(target,pname,param);
2545}
2546
2547void WIN32API glTexEnviv(GLenum target,
2548 GLenum pname,
2549 const GLint *params)
2550{
2551 OS2glTexEnviv(target,pname,params);
2552}
2553
2554void WIN32API glTexGend(GLenum coord,
2555 GLenum pname,
2556 GLdouble param)
2557{
2558 OS2glTexGend(coord,pname,param);
2559}
2560
2561void WIN32API glTexGendv(GLenum coord,
2562 GLenum pname,
2563 const GLdouble *params)
2564{
2565 OS2glTexGendv(coord,pname,params);
2566}
2567
2568void WIN32API glTexGenf(GLenum coord,
2569 GLenum pname,
2570 GLfloat param)
2571{
2572 OS2glTexGenf(coord,pname,param);
2573}
2574
2575void WIN32API glTexGenfv(GLenum coord,
2576 GLenum pname,
2577 const GLfloat *params)
2578{
2579 OS2glTexGenfv(coord,pname,params);
2580}
2581
2582void WIN32API glTexGeni(GLenum coord,
2583 GLenum pname,
2584 GLint param)
2585{
2586 OS2glTexGeni(coord,pname,param);
2587}
2588
2589void WIN32API glTexGeniv(GLenum coord,
2590 GLenum pname,
2591 const GLint *params)
2592{
2593 OS2glTexGeniv(coord,pname,params);
2594}
2595
2596
2597void WIN32API glTexImage1D(GLenum target,
2598 GLint level,
2599 GLint component,
2600 GLsizei width,
2601 GLint border,
2602 GLenum format,
2603 GLenum type,
2604 const GLvoid *pixels)
2605{
2606 OS2glTexImage1D(target,level,component,width,border,format,type,pixels);
2607}
2608
2609void WIN32API glTexImage2D(GLenum target,
2610 GLint level,
2611 GLint component,
2612 GLsizei width,
2613 GLsizei height,
2614 GLint border,
2615 GLenum format,
2616 GLenum type,
2617 const GLvoid *pixels)
2618{
2619 OS2glTexImage2D(target,level,component,width,height,border,format,type,pixels);
2620}
2621
2622void WIN32API glTexParameterf(GLenum target,
2623 GLenum pname,
2624 GLfloat param)
2625{
2626 OS2glTexParameterf(target,pname,param);
2627}
2628
2629void WIN32API glTexParameterfv(GLenum target,
2630 GLenum pname,
2631 const GLfloat *params)
2632{
2633 OS2glTexParameterfv(target,pname,params);
2634}
2635
2636void WIN32API glTexParameteri(GLenum target,
2637 GLenum pname,
2638 GLint param)
2639{
2640 OS2glTexParameteri(target,pname,param);
2641}
2642
2643void WIN32API glTexParameteriv(GLenum target,
2644 GLenum pname,
2645 const GLint *params)
2646{
2647 OS2glTexParameteriv(target,pname,params);
2648}
2649
2650void WIN32API glTranslated(GLdouble x,
2651 GLdouble y,
2652 GLdouble z)
2653{
2654 OS2glTranslated(x,y,z);
2655}
2656
2657void WIN32API glTranslatef(GLfloat x,
2658 GLfloat y,
2659 GLfloat z)
2660{
2661 OS2glTranslatef(x,y,z);
2662}
2663
2664void WIN32API glVertex2d(GLdouble x,
2665 GLdouble y)
2666{
2667 OS2glVertex2d(x,y);
2668}
2669
2670void WIN32API glVertex2dv(const GLdouble *v)
2671{
2672 OS2glVertex2dv(v);
2673}
2674
2675void WIN32API glVertex2f(GLfloat x,
2676 GLfloat y)
2677{
2678 OS2glVertex2f(x,y);
2679}
2680
2681void WIN32API glVertex2fv(const GLfloat *v)
2682{
2683 OS2glVertex2fv(v);
2684}
2685
2686void WIN32API glVertex2i(GLint x,
2687 GLint y)
2688{
2689 OS2glVertex2i(x,y);
2690}
2691
2692void WIN32API glVertex2iv(const GLint *v)
2693{
2694 OS2glVertex2iv(v);
2695}
2696
2697void WIN32API glVertex2s(GLshort x,
2698 GLshort y)
2699{
2700 OS2glVertex2s(x,y);
2701}
2702
2703void WIN32API glVertex2sv(const GLshort *v)
2704{
2705 OS2glVertex2sv(v);
2706}
2707
2708void WIN32API glVertex3d(GLdouble x,
2709 GLdouble y,
2710 GLdouble z)
2711{
2712 OS2glVertex3d(x,y,z);
2713}
2714
2715void WIN32API glVertex3dv(const GLdouble *v)
2716{
2717 OS2glVertex3dv(v);
2718}
2719
2720void WIN32API glVertex3f(GLfloat x,
2721 GLfloat y,
2722 GLfloat z)
2723{
2724 OS2glVertex3f(x,y,z);
2725}
2726
2727void WIN32API glVertex3fv(const GLfloat *v)
2728{
2729 OS2glVertex3fv(v);
2730}
2731
2732void WIN32API glVertex3i(GLint x,
2733 GLint y,
2734 GLint z)
2735{
2736 OS2glVertex3i(x,y,z);
2737}
2738
2739void WIN32API glVertex3iv(const GLint *v)
2740{
2741 OS2glVertex3iv(v);
2742}
2743
2744void WIN32API glVertex3s(GLshort x,
2745 GLshort y,
2746 GLshort z)
2747{
2748 OS2glVertex3s(x,y,z);
2749}
2750
2751void WIN32API glVertex3sv(const GLshort *v)
2752{
2753 OS2glVertex3sv(v);
2754}
2755
2756void WIN32API glVertex4d(GLdouble x,
2757 GLdouble y,
2758 GLdouble z,
2759 GLdouble w)
2760{
2761 OS2glVertex4d(x,y,z,w);
2762}
2763
2764void WIN32API glVertex4dv(const GLdouble *v)
2765{
2766 OS2glVertex4dv(v);
2767}
2768
2769void WIN32API glVertex4f(GLfloat x,
2770 GLfloat y,
2771 GLfloat z,
2772 GLfloat w)
2773{
2774 OS2glVertex4f(x,y,z,w);
2775}
2776
2777void WIN32API glVertex4fv(const GLfloat *v)
2778{
2779 OS2glVertex4fv(v);
2780}
2781
2782void WIN32API glVertex4i(GLint x,
2783 GLint y,
2784 GLint z,
2785 GLint w)
2786{
2787 OS2glVertex4i(x,y,z,w);
2788}
2789
2790void WIN32API glVertex4iv(const GLint *v)
2791{
2792 OS2glVertex4iv(v);
2793}
2794
2795void WIN32API glVertex4s(GLshort x,
2796 GLshort y,
2797 GLshort z,
2798 GLshort w)
2799{
2800 OS2glVertex4s(x,y,z,w);
2801}
2802
2803void WIN32API glVertex4sv(const GLshort *v)
2804{
2805 OS2glVertex4sv(v);
2806}
2807
2808void WIN32API glViewport(GLint x,
2809 GLint y,
2810 GLsizei width,
2811 GLsizei height)
2812{
2813 OS2glViewport(x,y,width,height);
2814}
2815
2816GLboolean WIN32API glAreTexturesResident(GLsizei in,
2817 const GLuint *textures,
2818 GLboolean *residences)
2819{
2820 return OS2glAreTexturesResident(in,textures,residences);
2821}
2822
2823void WIN32API glArrayElement(GLint i)
2824{
2825 OS2glArrayElement(i);
2826}
2827
2828void WIN32API glBindTexture(GLenum target,
2829 GLuint texture)
2830{
2831 OS2glBindTexture(target,texture);
2832}
2833
2834void WIN32API glColorPointer(GLint size,
2835 GLenum type,
2836 GLsizei stride,
2837 const GLvoid *pointer)
2838{
2839 OS2glColorPointer(size,type,stride,pointer);
2840}
2841
2842void WIN32API glCopyTexImage1D(GLenum target,
2843 GLint level,
2844 GLenum internalformat,
2845 GLint x,
2846 GLint y,
2847 GLsizei width,
2848 GLint border)
2849{
2850 OS2glCopyTexImage1D(target,level,internalformat,x,y,width,border);
2851}
2852
2853void WIN32API glCopyTexImage2D(GLenum target,
2854 GLint level,
2855 GLenum internalformat,
2856 GLint x,
2857 GLint y,
2858 GLsizei width,
2859 GLsizei height,
2860 GLint border)
2861{
2862 OS2glCopyTexImage2D(target,level,internalformat,x,y,width,height,border);
2863}
2864
2865void WIN32API glCopyTexSubImage1D(GLenum target,
2866 GLint level,
2867 GLint xoffset,
2868 GLint x,
2869 GLint y,
2870 GLsizei width)
2871{
2872 OS2glCopyTexSubImage1D(target,level,xoffset,x,y,width);
2873}
2874
2875void WIN32API glCopyTexSubImage2D(GLenum target,
2876 GLint level,
2877 GLint xoffset,
2878 GLint yoffset,
2879 GLint x,
2880 GLint y,
2881 GLsizei width,
2882 GLsizei height)
2883{
2884 OS2glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
2885}
2886
2887/*void WIN32API glDebugEntry(void)
2888{
2889}
2890*/
2891void WIN32API glDeleteTextures(GLsizei n,
2892 const GLuint *textures)
2893{
2894 OS2glDeleteTextures(n,textures);
2895}
2896
2897void WIN32API glDisableClientState(GLenum array)
2898{
2899 OS2glDisableClientState(array);
2900}
2901
2902void WIN32API glDrawArrays(GLenum mode,
2903 GLint first,
2904 GLsizei count)
2905{
2906 OS2glDrawArrays(mode,first,count);
2907}
2908
2909void WIN32API glDrawElements(GLenum mode,
2910 GLsizei count,
2911 GLenum type,
2912 const GLvoid *indices)
2913{
2914 OS2glDrawElements(mode,count,type,indices);
2915}
2916
2917void WIN32API glEdgeFlagPointer(GLsizei stride,
2918 const GLboolean *pointer)
2919{
2920 OS2glEdgeFlagPointer(stride,pointer);
2921}
2922
2923void WIN32API glEnableClientState(GLenum array)
2924{
2925 OS2glEnableClientState(array);
2926}
2927
2928void WIN32API glGenTextures(GLsizei n,
2929 GLuint *textures)
2930{
2931 OS2glGenTextures(n,textures);
2932}
2933
2934void WIN32API glGetPointerv(GLenum pname,
2935 GLvoid *params)
2936{
2937 OS2glGetPointerv(pname,params);
2938}
2939
2940void WIN32API glIndexPointer(GLenum type,
2941 GLsizei stride,
2942 const GLvoid *pointer)
2943{
2944 OS2glIndexPointer(type,stride,pointer);
2945}
2946
2947void WIN32API glIndexub(GLubyte c)
2948{
2949 OS2glIndexub(c);
2950}
2951
2952void WIN32API glIndexubv(const GLubyte *v)
2953{
2954 OS2glIndexubv(v);
2955}
2956
2957void WIN32API glInterleavedArrays(GLenum format,
2958 GLsizei stride,
2959 const GLvoid *pointer)
2960{
2961 OS2glInterleavedArrays(format,stride,pointer);
2962}
2963
2964GLboolean WIN32API glIsTexture(GLuint texture)
2965{
2966 return OS2glIsTexture(texture);
2967}
2968
2969void WIN32API glNormalPointer(GLenum type,
2970 GLsizei stride,
2971 const GLvoid *pointer)
2972{
2973 OS2glNormalPointer(type,stride,pointer);
2974}
2975
2976void WIN32API glPolygonOffset(GLfloat factor,
2977 GLfloat units)
2978{
2979 OS2glPolygonOffset(factor,units);
2980}
2981
2982void WIN32API glPopClientAttrib(void)
2983{
2984 OS2glPopClientAttrib();
2985}
2986
2987void WIN32API glPrioritizeTextures(GLsizei n,
2988 const GLuint *textures,
2989 const GLclampf *priorities)
2990{
2991 OS2glPrioritizeTextures(n,textures,priorities);
2992}
2993
2994void WIN32API glPushClientAttrib(GLbitfield mask)
2995{
2996 OS2glPushClientAttrib(mask);
2997}
2998
2999void WIN32API glTexCoordPointer(GLint size,
3000 GLenum type,
3001 GLsizei stride,
3002 const GLvoid *pointer)
3003{
3004 OS2glTexCoordPointer(size,type,stride,pointer);
3005}
3006
3007void WIN32API glTexSubImage1D(GLenum target,
3008 GLint level,
3009 GLint xoffset,
3010 GLsizei width,
3011 GLenum format,
3012 GLenum type,
3013 const GLvoid *pixels)
3014{
3015 OS2glTexSubImage1D(target,level,xoffset,width,format,type,pixels);
3016}
3017
3018void WIN32API glTexSubImage2D(GLenum target,
3019 GLint level,
3020 GLint xoffset,
3021 GLint yoffset,
3022 GLsizei width,
3023 GLsizei height,
3024 GLenum format,
3025 GLenum type,
3026 const GLvoid *pixels)
3027{
3028 OS2glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
3029}
3030
3031void WIN32API glVertexPointer(GLint size,
3032 GLenum type,
3033 GLsizei stride,
3034 GLsizei count,
3035 const GLvoid *pointer)
3036{
3037 OS2glVertexPointer(size,type,stride,count,pointer);
3038}
3039
3040/*****************************************************************************/
3041/* */
3042/* As of yet unsupported gl functions */
3043/* */
3044/*****************************************************************************/
3045
3046void WIN32API glTexImage3D(GLenum target,
3047 GLint level,
3048 GLint component,
3049 GLsizei width,
3050 GLsizei height,
3051 GLsizei depth,
3052 GLint border,
3053 GLenum format,
3054 GLenum type,
3055 const GLvoid *pixels)
3056{
3057 dprintf(("OPENGL32: glTexImage3D - not implemented\n"));
3058}
3059
3060/*****************************************************************************/
3061/* */
3062/* Module Internal init and cleanup - called by initterm */
3063/* */
3064/*****************************************************************************/
3065
3066void mod_init(void)
3067{
3068 /* OpenGL32 Initialize - Query all valid configs for this system and */
3069 /* store them. All indexes returned are based upon this list! */
3070 dprintf(("OPENGL32: INIT\n"));
3071
3072 _control87(EM_UNDERFLOW,EM_UNDERFLOW);
3073 _control87(EM_OVERFLOW,EM_OVERFLOW);
3074
3075 DosCreateMutexSem(NULL,&hmtxPfdInfo,0,0);
3076
3077 global_visual_config_count=0;
3078
3079 global_visual_config_list=
3080 OS2pglQueryConfigs(WinQueryAnchorBlock(HWND_DESKTOP));
3081
3082 if(global_visual_config_list)
3083 {
3084 while(global_visual_config_list[global_visual_config_count])
3085 global_visual_config_count++;
3086 }
3087
3088 dprintf(("OPENGL32 (INIT): global_visual_config_list: %08X [%d entries]\n",
3089 global_visual_config_list,
3090 global_visual_config_count));
3091}
3092
3093void mod_cleanup(void)
3094{
3095 /* Cleanup all structures we allocated */
3096 pfdi_destroy_all();
3097
3098 DosCloseMutexSem(hmtxPfdInfo);
3099
3100 _control87(0,EM_UNDERFLOW);
3101 _control87(0,EM_OVERFLOW);
3102
3103 dprintf(("OPENGL32 TERM\n"));
3104}
Note: See TracBrowser for help on using the repository browser.