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

Last change on this file since 2642 was 2595, checked in by sandervl, 26 years ago

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