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

Last change on this file since 2571 was 2532, checked in by sandervl, 26 years ago

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