source: trunk/src/opengl/mesa/api1.c@ 3079

Last change on this file since 3079 was 3079, checked in by jeroen, 25 years ago

* empty log message *
File size: 47.7 KB
Line 
1/* $Id: api1.c,v 1.2 2000-03-11 09:05:06 jeroen Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version: 3.1
6 *
7 * Copyright (C) 1999 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28
29
30#ifdef PC_HEADER
31#include "all.h"
32#else
33#ifndef XFree86Server
34#include <stdio.h>
35#include <stdlib.h>
36#else
37#include "GL/xf86glx.h"
38#endif
39#include "api.h"
40#include "bitmap.h"
41#include "context.h"
42#include "drawpix.h"
43#include "eval.h"
44#include "image.h"
45#include "light.h"
46#include "macros.h"
47#include "matrix.h"
48#include "mmath.h"
49#include "teximage.h"
50#include "types.h"
51#include "varray.h"
52#include "vb.h"
53#include "vbfill.h"
54#endif
55
56#include <misc.h>
57
58/*
59 * Part 1 of API functions
60 */
61
62void GLAPIENTRY glAccum(CTX_ARG GLenum op, GLfloat value )
63{
64 GET_CONTEXT;
65 CHECK_CONTEXT;
66 (*CC->API.Accum)(CC, op, value);
67}
68
69
70void GLAPIENTRY glAlphaFunc(CTX_ARG GLenum func, GLclampf ref )
71{
72 GET_CONTEXT;
73 CHECK_CONTEXT;
74 (*CC->API.AlphaFunc)(CC, func, ref);
75}
76
77
78GLboolean GLAPIENTRY glAreTexturesResident(CTX_ARG GLsizei n, const GLuint *textures,
79 GLboolean *residences )
80{
81 GET_CONTEXT;
82 CHECK_CONTEXT_RETURN(GL_FALSE);
83 return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
84}
85
86/* Enough funny business going on in here it might be quicker to use a
87 * function pointer.
88 */
89#define ARRAY_ELT( IM, i ) \
90{ \
91 GLuint count = IM->Count; \
92 IM->Elt[count] = i; \
93 IM->Flag[count] = ((IM->Flag[count] & IM->ArrayAndFlags) | \
94 VERT_ELT); \
95 IM->FlushElt |= IM->ArrayEltFlush; \
96 IM->Count = count += IM->ArrayIncr; \
97 if (count == VB_MAX) \
98 IM->maybe_transform_vb( IM ); \
99}
100
101
102void GLAPIENTRY glArrayElement(CTX_ARG GLint i )
103{
104 GET_IMMEDIATE;
105 ARRAY_ELT( IM, i );
106}
107
108
109void GLAPIENTRY glArrayElementEXT(CTX_ARG GLint i )
110{
111 GET_IMMEDIATE;
112 ARRAY_ELT( IM, i );
113}
114
115
116void gl_ArrayElement( GLcontext *CC, GLint i )
117{
118 struct immediate *im = CC->input;
119 ARRAY_ELT( im, i );
120}
121
122
123void GLAPIENTRY glBegin(CTX_ARG GLenum mode )
124{
125 GET_CONTEXT;
126
127 if (mode < GL_POINTS || mode > GL_POLYGON) {
128 gl_compile_error( CC, GL_INVALID_ENUM, "glBegin" );
129 return;
130 }
131
132 gl_Begin(CC,mode);
133}
134
135
136void GLAPIENTRY glBindTexture(CTX_ARG GLenum target, GLuint texture )
137{
138 GET_CONTEXT;
139 CHECK_CONTEXT;
140 (*CC->API.BindTexture)(CC, target, texture);
141}
142
143
144void GLAPIENTRY glBitmap(CTX_ARG GLsizei width, GLsizei height,
145 GLfloat xorig, GLfloat yorig,
146 GLfloat xmove, GLfloat ymove,
147 const GLubyte *bitmap )
148{
149 GET_CONTEXT;
150 CHECK_CONTEXT;
151 (*CC->API.Bitmap)( CC, width, height, xorig, yorig, xmove, ymove, bitmap,
152 &CC->Unpack );
153}
154
155
156void GLAPIENTRY glBlendFunc(CTX_ARG GLenum sfactor, GLenum dfactor )
157{
158 GET_CONTEXT;
159 CHECK_CONTEXT;
160 (*CC->API.BlendFunc)(CC, sfactor, dfactor);
161}
162
163
164void GLAPIENTRY glCallList(CTX_ARG GLuint list )
165{
166 GET_CONTEXT;
167 CHECK_CONTEXT;
168 (*CC->API.CallList)(CC, list);
169}
170
171
172void GLAPIENTRY glCallLists(CTX_ARG GLsizei n, GLenum type, const GLvoid *lists )
173{
174 GET_CONTEXT;
175 CHECK_CONTEXT;
176 (*CC->API.CallLists)(CC, n, type, lists);
177}
178
179
180void GLAPIENTRY glClear(CTX_ARG GLbitfield mask )
181{
182 GET_CONTEXT;
183 CHECK_CONTEXT;
184 (*CC->API.Clear)(CC, mask);
185}
186
187
188void GLAPIENTRY glClearAccum(CTX_ARG GLfloat red, GLfloat green,
189 GLfloat blue, GLfloat alpha )
190{
191 GET_CONTEXT;
192 CHECK_CONTEXT;
193 (*CC->API.ClearAccum)(CC, red, green, blue, alpha);
194}
195
196
197
198void GLAPIENTRY glClearIndex(CTX_ARG GLfloat c )
199{
200 GET_CONTEXT;
201 CHECK_CONTEXT;
202 (*CC->API.ClearIndex)(CC, c);
203}
204
205
206void GLAPIENTRY glClearColor(CTX_ARG GLclampf red, GLclampf green,
207 GLclampf blue, GLclampf alpha )
208{
209 GET_CONTEXT;
210 CHECK_CONTEXT;
211 (*CC->API.ClearColor)(CC, red, green, blue, alpha);
212}
213
214
215void GLAPIENTRY glClearDepth(CTX_ARG GLclampd depth )
216{
217 GET_CONTEXT;
218 CHECK_CONTEXT;
219 (*CC->API.ClearDepth)( CC, depth );
220}
221
222
223void GLAPIENTRY glClearStencil(CTX_ARG GLint s )
224{
225 GET_CONTEXT;
226 CHECK_CONTEXT;
227 (*CC->API.ClearStencil)(CC, s);
228}
229
230
231void GLAPIENTRY glClipPlane(CTX_ARG GLenum plane, const GLdouble *equation )
232{
233 GLfloat eq[4];
234 GET_CONTEXT;
235 CHECK_CONTEXT;
236 eq[0] = (GLfloat) equation[0];
237 eq[1] = (GLfloat) equation[1];
238 eq[2] = (GLfloat) equation[2];
239 eq[3] = (GLfloat) equation[3];
240 (*CC->API.ClipPlane)(CC, plane, eq );
241}
242
243
244/* KW: Again, a stateless implementation of these functions. The big
245 * news here is the impact on color material. This was previously
246 * handled by swaping the function pointers that these API's used to
247 * call. This is no longer possible, and we have to pick up the
248 * pieces later on and make them work with either color-color, or
249 * color-material.
250 *
251 * But in truth, this is not a bad thing, because it was necessary
252 * to implement that mechanism to get good performance from
253 * color-material and vertex arrays.
254 */
255#define COLOR( IM, r,g,b,a ) \
256{ \
257 GLuint count = IM->Count; \
258 IM->Flag[count] |= VERT_RGBA; \
259 IM->Color[count][0] = r; \
260 IM->Color[count][1] = g; \
261 IM->Color[count][2] = b; \
262 IM->Color[count][3] = a; \
263}
264
265#if 0
266#define COLOR4F( IM, r,g,b,a ) \
267{ \
268 GLuint count = IM->Count; \
269 IM->Flag[count] |= VERT_RGBA | VERT_FLOAT_RGBA; \
270 IM->FloatColor[count][0] = r; \
271 IM->FloatColor[count][1] = g; \
272 IM->FloatColor[count][2] = b; \
273 IM->FloatColor[count][3] = a; \
274}
275#else
276#define COLOR4F(IM, r, g, b, a) \
277{ \
278 GLubyte col[4]; \
279 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r); \
280 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g); \
281 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b); \
282 FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a); \
283 COLORV( IM, col ); \
284}
285#endif
286
287
288
289#define COLORV( IM, v ) \
290{ \
291 GLuint count = IM->Count; \
292 IM->Flag[count] |= VERT_RGBA; \
293 COPY_4UBV(IM->Color[count], v); \
294}
295
296
297void GLAPIENTRY glColor3b(CTX_ARG GLbyte red, GLbyte green, GLbyte blue )
298{
299 GET_IMMEDIATE;
300 COLOR( IM,
301 BYTE_TO_UBYTE(red),
302 BYTE_TO_UBYTE(green),
303 BYTE_TO_UBYTE(blue),
304 255 );
305}
306
307
308void GLAPIENTRY glColor3d(CTX_ARG GLdouble red, GLdouble green, GLdouble blue )
309{
310 GLubyte col[4];
311 GLfloat r = red;
312 GLfloat g = green;
313 GLfloat b = blue;
314 GET_IMMEDIATE;
315 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
316 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
317 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
318 col[3] = 255;
319 COLORV( IM, col );
320
321/* COLOR4F( IM, red, green, blue, 1.0 ); */
322}
323
324
325void GLAPIENTRY glColor3f(CTX_ARG GLfloat red, GLfloat green, GLfloat blue )
326{
327 GLubyte col[4];
328 GET_IMMEDIATE;
329 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], red);
330 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], green);
331 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], blue);
332 col[3] = 255;
333 COLORV( IM, col );
334
335/* COLOR4F( IM, red, green, blue, 1.0 ); */
336}
337
338
339void GLAPIENTRY glColor3i(CTX_ARG GLint red, GLint green, GLint blue )
340{
341 GET_IMMEDIATE;
342 COLOR( IM, INT_TO_UBYTE(red),
343 INT_TO_UBYTE(green),
344 INT_TO_UBYTE(blue),
345 255);
346}
347
348
349void GLAPIENTRY glColor3s(CTX_ARG GLshort red, GLshort green, GLshort blue )
350{
351 GET_IMMEDIATE;
352 COLOR( IM, SHORT_TO_UBYTE(red),
353 SHORT_TO_UBYTE(green),
354 SHORT_TO_UBYTE(blue),
355 255);
356}
357
358
359void GLAPIENTRY glColor3ub(CTX_ARG GLubyte red, GLubyte green, GLubyte blue )
360{
361 GET_IMMEDIATE;
362 COLOR( IM, red, green, blue, 255 );
363}
364
365
366void GLAPIENTRY glColor3ui(CTX_ARG GLuint red, GLuint green, GLuint blue )
367{
368 GET_IMMEDIATE;
369 COLOR( IM, UINT_TO_UBYTE(red),
370 UINT_TO_UBYTE(green),
371 UINT_TO_UBYTE(blue),
372 255 );
373}
374
375
376void GLAPIENTRY glColor3us(CTX_ARG GLushort red, GLushort green, GLushort blue )
377{
378 GET_IMMEDIATE;
379 COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
380 USHORT_TO_UBYTE(blue),
381 255 );
382}
383
384
385void GLAPIENTRY glColor4b(CTX_ARG GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
386{
387 GET_IMMEDIATE;
388 COLOR( IM, BYTE_TO_UBYTE(red), BYTE_TO_UBYTE(green),
389 BYTE_TO_UBYTE(blue), BYTE_TO_UBYTE(alpha) );
390}
391
392
393void GLAPIENTRY glColor4d(CTX_ARG GLdouble red, GLdouble green, GLdouble blue,
394 GLdouble alpha )
395{
396 GLubyte col[4];
397 GLfloat r = red;
398 GLfloat g = green;
399 GLfloat b = blue;
400 GLfloat a = alpha;
401 GET_IMMEDIATE;
402 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
403 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
404 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
405 FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);
406 COLORV( IM, col );
407
408/* COLOR4F( IM, red, green, blue, alpha ); */
409}
410
411
412void GLAPIENTRY glColor4f(CTX_ARG GLfloat red, GLfloat green,
413 GLfloat blue, GLfloat alpha )
414{
415 GLubyte col[4];
416 GET_IMMEDIATE;
417 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], red);
418 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], green);
419 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], blue);
420 FLOAT_COLOR_TO_UBYTE_COLOR(col[3], alpha);
421 COLORV( IM, col );
422
423/* COLOR4F( IM, red, green, blue, alpha ); */
424}
425
426void GLAPIENTRY glColor4i(CTX_ARG GLint red, GLint green, GLint blue, GLint alpha )
427{
428 GET_IMMEDIATE;
429 COLOR( IM, INT_TO_UBYTE(red), INT_TO_UBYTE(green),
430 INT_TO_UBYTE(blue), INT_TO_UBYTE(alpha) );
431}
432
433
434void GLAPIENTRY glColor4s(CTX_ARG GLshort red, GLshort green,
435 GLshort blue, GLshort alpha )
436{
437 GET_IMMEDIATE;
438 COLOR( IM, SHORT_TO_UBYTE(red), SHORT_TO_UBYTE(green),
439 SHORT_TO_UBYTE(blue), SHORT_TO_UBYTE(alpha) );
440}
441
442void GLAPIENTRY glColor4ub(CTX_ARG GLubyte red, GLubyte green,
443 GLubyte blue, GLubyte alpha )
444{
445 GET_IMMEDIATE;
446 COLOR( IM, red, green, blue, alpha );
447}
448
449void GLAPIENTRY glColor4ui(CTX_ARG GLuint red, GLuint green,
450 GLuint blue, GLuint alpha )
451{
452 GET_IMMEDIATE;
453 COLOR( IM, UINT_TO_UBYTE(red), UINT_TO_UBYTE(green),
454 UINT_TO_UBYTE(blue), UINT_TO_UBYTE(alpha) );
455}
456
457void GLAPIENTRY glColor4us(CTX_ARG GLushort red, GLushort green,
458 GLushort blue, GLushort alpha )
459{
460 GET_IMMEDIATE;
461 COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
462 USHORT_TO_UBYTE(blue), USHORT_TO_UBYTE(alpha) );
463}
464
465
466void GLAPIENTRY glColor3bv(CTX_ARG const GLbyte *v )
467{
468 GET_IMMEDIATE;
469 COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
470 BYTE_TO_UBYTE(v[2]), 255 );
471}
472
473
474void GLAPIENTRY glColor3dv(CTX_ARG const GLdouble *v )
475{
476 GLubyte col[4];
477 GLfloat r = v[0];
478 GLfloat g = v[1];
479 GLfloat b = v[2];
480 GET_IMMEDIATE;
481 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
482 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
483 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
484 col[3]= 255;
485 COLORV( IM, col );
486
487/* COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
488}
489
490
491void GLAPIENTRY glColor3fv(CTX_ARG const GLfloat *v )
492{
493 GLubyte col[4];
494 GET_IMMEDIATE;
495 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], v[0]);
496 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], v[1]);
497 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], v[2]);
498 col[3] = 255;
499 COLORV( IM, col );
500
501/* COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
502}
503
504
505void GLAPIENTRY glColor3iv(CTX_ARG const GLint *v )
506{
507 GET_IMMEDIATE;
508 COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
509 INT_TO_UBYTE(v[2]), 255 );
510}
511
512
513void GLAPIENTRY glColor3sv(CTX_ARG const GLshort *v )
514{
515 GET_IMMEDIATE;
516 COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
517 SHORT_TO_UBYTE(v[2]), 255 );
518}
519
520
521void GLAPIENTRY glColor3ubv(CTX_ARG const GLubyte *v )
522{
523 GET_IMMEDIATE;
524 COLOR( IM, v[0], v[1], v[2], 255 );
525}
526
527
528void GLAPIENTRY glColor3uiv(CTX_ARG const GLuint *v )
529{
530 GET_IMMEDIATE;
531 COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
532 UINT_TO_UBYTE(v[2]), 255 );
533}
534
535
536void GLAPIENTRY glColor3usv(CTX_ARG const GLushort *v )
537{
538 GET_IMMEDIATE;
539 COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
540 USHORT_TO_UBYTE(v[2]), 255 );
541
542}
543
544
545void GLAPIENTRY glColor4bv(CTX_ARG const GLbyte *v )
546{
547 GET_IMMEDIATE;
548 COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
549 BYTE_TO_UBYTE(v[2]), BYTE_TO_UBYTE(v[3]) );
550}
551
552
553void GLAPIENTRY glColor4dv(CTX_ARG const GLdouble *v )
554{
555 GLubyte col[4];
556 GLfloat r = v[0];
557 GLfloat g = v[1];
558 GLfloat b = v[2];
559 GLfloat a = v[3];
560 GET_IMMEDIATE;
561 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
562 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
563 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
564 FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);
565 COLORV( IM, col );
566
567/* COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
568}
569
570
571void GLAPIENTRY glColor4fv(CTX_ARG const GLfloat *v )
572{
573 GLubyte col[4];
574 GET_IMMEDIATE;
575 FLOAT_COLOR_TO_UBYTE_COLOR(col[0], v[0]);
576 FLOAT_COLOR_TO_UBYTE_COLOR(col[1], v[1]);
577 FLOAT_COLOR_TO_UBYTE_COLOR(col[2], v[2]);
578 FLOAT_COLOR_TO_UBYTE_COLOR(col[3], v[3]);
579 COLORV( IM, col );
580
581/* COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
582}
583
584
585void GLAPIENTRY glColor4iv(CTX_ARG const GLint *v )
586{
587 GET_IMMEDIATE;
588 COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
589 INT_TO_UBYTE(v[2]), INT_TO_UBYTE(v[3]) );
590}
591
592
593void GLAPIENTRY glColor4sv(CTX_ARG const GLshort *v )
594{
595 GET_IMMEDIATE;
596 COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
597 SHORT_TO_UBYTE(v[2]), SHORT_TO_UBYTE(v[3]) );
598}
599
600
601void GLAPIENTRY glColor4ubv(CTX_ARG const GLubyte *v )
602{
603 GET_IMMEDIATE;
604 COLORV( IM, v );
605}
606
607
608void GLAPIENTRY glColor4uiv(CTX_ARG const GLuint *v )
609{
610 GET_IMMEDIATE;
611 COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
612 UINT_TO_UBYTE(v[2]), UINT_TO_UBYTE(v[3]) );
613}
614
615
616void GLAPIENTRY glColor4usv(CTX_ARG const GLushort *v )
617{
618 GET_IMMEDIATE;
619 COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
620 USHORT_TO_UBYTE(v[2]), USHORT_TO_UBYTE(v[3]) );
621}
622
623
624void GLAPIENTRY glColorMask(CTX_ARG GLboolean red, GLboolean green,
625 GLboolean blue, GLboolean alpha )
626{
627 GET_CONTEXT;
628 CHECK_CONTEXT;
629 (*CC->API.ColorMask)(CC, red, green, blue, alpha);
630}
631
632
633void GLAPIENTRY glColorMaterial(CTX_ARG GLenum face, GLenum mode )
634{
635 GET_CONTEXT;
636 CHECK_CONTEXT;
637 (*CC->API.ColorMaterial)(CC, face, mode);
638}
639
640
641void GLAPIENTRY glCopyPixels(CTX_ARG GLint x, GLint y, GLsizei width, GLsizei height,
642 GLenum type )
643{
644 GET_CONTEXT;
645 CHECK_CONTEXT;
646 (*CC->API.CopyPixels)(CC, x, y, width, height, type);
647}
648
649
650void GLAPIENTRY glCopyTexImage1D(CTX_ARG GLenum target, GLint level,
651 GLenum internalformat,
652 GLint x, GLint y,
653 GLsizei width, GLint border )
654{
655 GET_CONTEXT;
656 CHECK_CONTEXT;
657 (*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
658 x, y, width, border );
659}
660
661
662void GLAPIENTRY glCopyTexImage2D(CTX_ARG GLenum target, GLint level,
663 GLenum internalformat,
664 GLint x, GLint y,
665 GLsizei width, GLsizei height, GLint border )
666{
667 GET_CONTEXT;
668 CHECK_CONTEXT;
669 (*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
670 x, y, width, height, border );
671}
672
673
674void GLAPIENTRY glCopyTexSubImage1D(CTX_ARG GLenum target, GLint level,
675 GLint xoffset, GLint x, GLint y,
676 GLsizei width )
677{
678 GET_CONTEXT;
679 CHECK_CONTEXT;
680 (*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
681}
682
683
684void GLAPIENTRY glCopyTexSubImage2D(CTX_ARG GLenum target, GLint level,
685 GLint xoffset, GLint yoffset,
686 GLint x, GLint y,
687 GLsizei width, GLsizei height )
688{
689 GET_CONTEXT;
690 CHECK_CONTEXT;
691 (*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
692 x, y, width, height );
693}
694
695
696/* 1.2 */
697void GLAPIENTRY glCopyTexSubImage3D(CTX_ARG GLenum target, GLint level, GLint xoffset,
698 GLint yoffset, GLint zoffset,
699 GLint x, GLint y, GLsizei width,
700 GLsizei height )
701{
702 GET_CONTEXT;
703 CHECK_CONTEXT;
704 (*CC->API.CopyTexSubImage3D)( CC, target, level, xoffset, yoffset,
705 zoffset, x, y, width, height );
706}
707
708
709
710void GLAPIENTRY glCullFace(CTX_ARG GLenum mode )
711{
712 GET_CONTEXT;
713 CHECK_CONTEXT;
714 (*CC->API.CullFace)(CC, mode);
715}
716
717
718void GLAPIENTRY glDepthFunc(CTX_ARG GLenum func )
719{
720 GET_CONTEXT;
721 CHECK_CONTEXT;
722 (*CC->API.DepthFunc)( CC, func );
723}
724
725
726void GLAPIENTRY glDepthMask(CTX_ARG GLboolean flag )
727{
728 GET_CONTEXT;
729 CHECK_CONTEXT;
730 (*CC->API.DepthMask)( CC, flag );
731}
732
733
734void GLAPIENTRY glDepthRange(CTX_ARG GLclampd near_val, GLclampd far_val )
735{
736 GET_CONTEXT;
737 CHECK_CONTEXT;
738 (*CC->API.DepthRange)( CC, near_val, far_val );
739}
740
741
742void GLAPIENTRY glDeleteLists(CTX_ARG GLuint list, GLsizei range )
743{
744 GET_CONTEXT;
745 CHECK_CONTEXT;
746 (*CC->API.DeleteLists)(CC, list, range);
747}
748
749
750void GLAPIENTRY glDeleteTextures(CTX_ARG GLsizei n, const GLuint *textures )
751{
752 GET_CONTEXT;
753 CHECK_CONTEXT;
754 (*CC->API.DeleteTextures)(CC, n, textures);
755}
756
757
758void GLAPIENTRY glDisable(CTX_ARG GLenum cap )
759{
760 GET_CONTEXT;
761 CHECK_CONTEXT;
762 (*CC->API.Disable)( CC, cap );
763}
764
765
766void GLAPIENTRY glDisableClientState(CTX_ARG GLenum cap )
767{
768 GET_CONTEXT;
769 CHECK_CONTEXT;
770 (*CC->API.DisableClientState)( CC, cap );
771}
772
773
774void GLAPIENTRY glDrawArrays(CTX_ARG GLenum mode, GLint first, GLsizei count )
775{
776 GET_CONTEXT;
777 CHECK_CONTEXT;
778 gl_DrawArrays(CC, mode, first, count);
779}
780
781
782void GLAPIENTRY glDrawBuffer(CTX_ARG GLenum mode )
783{
784 GET_CONTEXT;
785 CHECK_CONTEXT;
786 (*CC->API.DrawBuffer)(CC, mode);
787}
788
789
790
791void GLAPIENTRY glDrawPixels(CTX_ARG GLsizei width, GLsizei height, GLenum format,
792 GLenum type, const GLvoid *pixels )
793{
794 GET_CONTEXT;
795 CHECK_CONTEXT;
796 if (CC->CompileFlag || !gl_direct_DrawPixels(CC, &CC->Unpack, width, height,
797 format, type, pixels)) {
798 struct gl_image *image;
799 image = gl_unpack_image( CC, width, height, format, type, pixels, &CC->Unpack );
800 (*CC->API.DrawPixels)( CC, image );
801 if (image->RefCount==0) {
802 /* image not in display list */
803 gl_free_image( image );
804 }
805 }
806}
807
808
809void GLAPIENTRY glEnable(CTX_ARG GLenum cap )
810{
811 GET_CONTEXT;
812 CHECK_CONTEXT;
813 (*CC->API.Enable)( CC, cap );
814}
815
816
817void GLAPIENTRY glEnableClientState(CTX_ARG GLenum cap )
818{
819 GET_CONTEXT;
820 CHECK_CONTEXT;
821 (*CC->API.EnableClientState)( CC, cap );
822}
823
824
825/* KW: Both streams now go to the outside-begin-end state. Raise
826 * errors for either stream if it was not in the inside state.
827 */
828void GLAPIENTRY glEnd(CTX_VOID )
829{
830 GLuint state;
831 GLuint inflags;
832 GET_IMMEDIATE;
833
834
835 state = IM->BeginState;
836 inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
837 state |= inflags << 2; /* errors */
838
839 if (MESA_VERBOSE&VERBOSE_API) {
840 if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
841 fprintf(stderr, "glEnd(IM %d), BeginState is %x, errors %x\n",
842 IM->id, state,
843 inflags<<2);
844 else
845 fprintf(stderr, ">");
846 }
847
848
849 if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
850 {
851 GLuint count = IM->Count;
852 GLuint last = IM->LastPrimitive;
853
854 state &= ~(VERT_BEGIN_0|VERT_BEGIN_1); /* update state */
855 IM->Flag[count] |= VERT_END;
856 IM->NextPrimitive[IM->LastPrimitive] = count;
857 IM->LastPrimitive = count;
858 IM->Primitive[count] = GL_POLYGON+1;
859
860 if (IM->FlushElt) {
861 gl_exec_array_elements( IM->backref, IM, last, count );
862 IM->FlushElt = 0;
863 }
864 }
865
866 if (MESA_VERBOSE&VERBOSE_API)
867 fprintf(stderr, "in glEnd final state %x\n", state);
868
869 IM->BeginState = state;
870
871 if ((MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH))
872 IM->maybe_transform_vb( IM );
873}
874
875
876void gl_End( GLcontext *ctx )
877{
878 struct immediate *IM = ctx->input;
879 GLuint state = IM->BeginState;
880 GLuint inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
881
882
883 if (MESA_VERBOSE&VERBOSE_API) {
884 if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
885 fprintf(stderr, "gl_End(IM %d), BeginState is %x, errors %x\n",
886 IM->id, state,
887 inflags<<2);
888 else
889 fprintf(stderr, ">");
890 }
891
892 state |= inflags << 2; /* errors */
893
894 if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
895 {
896 GLuint count = IM->Count;
897 GLuint last = IM->LastPrimitive;
898
899 state &= ~(VERT_BEGIN_0|VERT_BEGIN_1); /* update state */
900 IM->Flag[count] |= VERT_END;
901 IM->NextPrimitive[IM->LastPrimitive] = count;
902 IM->LastPrimitive = count;
903 IM->Primitive[count] = GL_POLYGON+1;
904
905 if (IM->FlushElt) {
906 gl_exec_array_elements( ctx, IM, last, count );
907 IM->FlushElt = 0;
908 }
909 }
910
911 IM->BeginState = state;
912
913 /* You can set this flag to get the old 'flush vb on glEnd()'
914 * behaviour.
915 */
916 if ((MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH))
917 IM->maybe_transform_vb( IM );
918}
919
920void GLAPIENTRY glEndList(CTX_VOID )
921{
922 GET_CONTEXT;
923 CHECK_CONTEXT;
924 (*CC->API.EndList)(CC);
925}
926
927/* KW: If are compiling, we don't know whether eval will produce a
928 * vertex when it is run in the future. If this is pure immediate
929 * mode, eval is a noop if neither vertex map is enabled.
930 *
931 * Thus we need to have a check in the display list code or
932 * elsewhere for eval(1,2) vertices in the case where
933 * map(1,2)_vertex is disabled, and to purge those vertices from
934 * the vb. This is currently done
935 * via modifications to the cull_vb and render_vb operations, and
936 * by using the existing cullmask mechanism for all other operations.
937 */
938
939
940/* KW: Because the eval values don't become 'current', fixup will flow
941 * through these vertices, and then evaluation will write on top
942 * of the fixup results.
943 *
944 * This is a little inefficient, but at least it is correct. This
945 * could be short-circuited in the case where all vertices are
946 * eval-vertices, or more generally by a cullmask in fixup.
947 *
948 * Note: using Obj to hold eval coord data. This data is actually
949 * transformed if eval is disabled. But disabling eval & sending
950 * eval coords is stupid, right?
951 */
952
953
954#define EVALCOORD1(IM, x) \
955{ \
956 GLuint count = IM->Count++; \
957 IM->Flag[count] |= VERT_EVAL_C1; \
958 ASSIGN_4V(IM->Obj[count], x, 0, 0, 1); \
959 if (count == VB_MAX-1) \
960 IM->maybe_transform_vb( IM ); \
961}
962
963#define EVALCOORD2(IM, x, y) \
964{ \
965 GLuint count = IM->Count++; \
966 IM->Flag[count] |= VERT_EVAL_C2; \
967 ASSIGN_4V(IM->Obj[count], x, y, 0, 1); \
968 WriteLog("OPENGL32: EVALCOORD2 (%f,%f) IM: %08X - cnt %d\n",x,y,IM,count); \
969 if (count == VB_MAX-1) \
970 {WriteLog("OPENGL32: EVALCOORD2 is calling maybe_transform\n"); \
971 IM->maybe_transform_vb( IM ); }\
972}
973
974#define EVALPOINT1(IM, x) \
975{ \
976 GLuint count = IM->Count++; \
977 IM->Flag[count] |= VERT_EVAL_P1; \
978 ASSIGN_4V(IM->Obj[count], x, 0, 0, 1); \
979 if (count == VB_MAX-1) \
980 IM->maybe_transform_vb( IM ); \
981}
982
983#define EVALPOINT2(IM, x, y) \
984{ \
985 GLuint count = IM->Count++; \
986 IM->Flag[count] |= VERT_EVAL_P2; \
987 ASSIGN_4V(IM->Obj[count], x, y, 0, 1); \
988 if (count == VB_MAX-1) \
989 IM->maybe_transform_vb( IM ); \
990}
991
992
993void GLAPIENTRY glEvalCoord1d(CTX_ARG GLdouble u )
994{
995 GET_IMMEDIATE;
996 EVALCOORD1( IM, (GLfloat) u );
997}
998
999
1000void GLAPIENTRY glEvalCoord1f(CTX_ARG GLfloat u )
1001{
1002 GET_IMMEDIATE;
1003 EVALCOORD1( IM, u );
1004}
1005
1006
1007/* Lame internal function:
1008 */
1009void gl_EvalCoord1f( GLcontext *CC, GLfloat u )
1010{
1011 struct immediate *i = CC->input;
1012 EVALCOORD1( i, u );
1013}
1014
1015
1016void GLAPIENTRY glEvalCoord1dv(CTX_ARG const GLdouble *u )
1017{
1018 GET_IMMEDIATE;
1019 EVALCOORD1( IM, (GLfloat) *u );
1020}
1021
1022
1023void GLAPIENTRY glEvalCoord1fv(CTX_ARG const GLfloat *u )
1024{
1025 GET_IMMEDIATE;
1026 EVALCOORD1( IM, (GLfloat) *u );
1027}
1028
1029
1030void GLAPIENTRY glEvalCoord2d(CTX_ARG GLdouble u, GLdouble v )
1031{
1032 GET_IMMEDIATE;
1033 EVALCOORD2( IM, (GLfloat) u, (GLfloat) v );
1034}
1035
1036
1037void GLAPIENTRY glEvalCoord2f(CTX_ARG GLfloat u, GLfloat v )
1038{
1039 GET_IMMEDIATE;
1040 EVALCOORD2( IM, u, v );
1041}
1042
1043
1044/* Lame internal function:
1045 */
1046void gl_EvalCoord2f( GLcontext *CC, GLfloat u, GLfloat v )
1047{
1048 struct immediate *i = CC->input;
1049 EVALCOORD2( i, u, v );
1050}
1051
1052
1053void GLAPIENTRY glEvalCoord2dv(CTX_ARG const GLdouble *u )
1054{
1055 GET_IMMEDIATE;
1056 EVALCOORD2( IM, (GLfloat) u[0], (GLfloat) u[1] );
1057}
1058
1059
1060void GLAPIENTRY glEvalCoord2fv(CTX_ARG const GLfloat *u )
1061{
1062 GET_IMMEDIATE;
1063 EVALCOORD2( IM, u[0], u[1] );
1064}
1065
1066
1067void GLAPIENTRY glEvalPoint1(CTX_ARG GLint i )
1068{
1069 GET_IMMEDIATE;
1070 EVALPOINT1( IM, i );
1071}
1072
1073
1074void GLAPIENTRY glEvalPoint2(CTX_ARG GLint i, GLint j )
1075{
1076 GET_IMMEDIATE;
1077 EVALPOINT2( IM, i, j );
1078}
1079
1080
1081void GLAPIENTRY glEvalMesh1(CTX_ARG GLenum mode, GLint i1, GLint i2 )
1082{
1083 GET_CONTEXT;
1084 CHECK_CONTEXT;
1085 (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
1086}
1087
1088
1089void GLAPIENTRY glEdgeFlag(CTX_ARG GLboolean flag )
1090{
1091 GLuint count;
1092 GET_IMMEDIATE;
1093 count = IM->Count;
1094 IM->EdgeFlag[count] = flag;
1095 IM->Flag[count] |= VERT_EDGE;
1096}
1097
1098
1099void GLAPIENTRY glEdgeFlagv(CTX_ARG const GLboolean *flag )
1100{
1101 GLuint count;
1102 GET_IMMEDIATE;
1103 count = IM->Count;
1104 IM->EdgeFlag[count] = *flag;
1105 IM->Flag[count] |= VERT_EDGE;
1106}
1107
1108
1109
1110void GLAPIENTRY glEvalMesh2(CTX_ARG GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
1111{
1112 GET_CONTEXT;
1113 CHECK_CONTEXT;
1114 (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
1115}
1116
1117
1118void GLAPIENTRY glFeedbackBuffer(CTX_ARG GLsizei size, GLenum type, GLfloat *buffer )
1119{
1120 GET_CONTEXT;
1121 CHECK_CONTEXT;
1122 (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
1123}
1124
1125
1126void GLAPIENTRY glFinish(CTX_VOID )
1127{
1128 GET_CONTEXT;
1129 CHECK_CONTEXT;
1130 (*CC->API.Finish)(CC);
1131}
1132
1133
1134void GLAPIENTRY glFlush(CTX_VOID )
1135{
1136 GET_CONTEXT;
1137 CHECK_CONTEXT;
1138 (*CC->API.Flush)(CC);
1139}
1140
1141
1142void GLAPIENTRY glFogf(CTX_ARG GLenum pname, GLfloat param )
1143{
1144 GET_CONTEXT;
1145 CHECK_CONTEXT;
1146 (*CC->API.Fogfv)(CC, pname, &param);
1147}
1148
1149
1150void GLAPIENTRY glFogi(CTX_ARG GLenum pname, GLint param )
1151{
1152 GLfloat fparam = (GLfloat) param;
1153 GET_CONTEXT;
1154 CHECK_CONTEXT;
1155 (*CC->API.Fogfv)(CC, pname, &fparam);
1156}
1157
1158
1159void GLAPIENTRY glFogfv(CTX_ARG GLenum pname, const GLfloat *params )
1160{
1161 GET_CONTEXT;
1162 CHECK_CONTEXT;
1163 (*CC->API.Fogfv)(CC, pname, params);
1164}
1165
1166
1167void GLAPIENTRY glFogiv(CTX_ARG GLenum pname, const GLint *params )
1168{
1169 GLfloat p[4];
1170 GET_CONTEXT;
1171 CHECK_CONTEXT;
1172
1173 switch (pname) {
1174 case GL_FOG_MODE:
1175 case GL_FOG_DENSITY:
1176 case GL_FOG_START:
1177 case GL_FOG_END:
1178 case GL_FOG_INDEX:
1179 p[0] = (GLfloat) *params;
1180 break;
1181 case GL_FOG_COLOR:
1182 p[0] = INT_TO_FLOAT( params[0] );
1183 p[1] = INT_TO_FLOAT( params[1] );
1184 p[2] = INT_TO_FLOAT( params[2] );
1185 p[3] = INT_TO_FLOAT( params[3] );
1186 break;
1187 default:
1188 /* Error will be caught later in gl_Fogfv */
1189 ;
1190 }
1191 (*CC->API.Fogfv)( CC, pname, p );
1192}
1193
1194
1195void GLAPIENTRY glFrontFace(CTX_ARG GLenum mode )
1196{
1197 GET_CONTEXT;
1198 CHECK_CONTEXT;
1199 (*CC->API.FrontFace)(CC, mode);
1200}
1201
1202
1203void GLAPIENTRY glFrustum(CTX_ARG GLdouble left, GLdouble right,
1204 GLdouble bottom, GLdouble top,
1205 GLdouble nearval, GLdouble farval )
1206{
1207 GET_CONTEXT;
1208 CHECK_CONTEXT;
1209 (*CC->API.Frustum)(CC, left, right, bottom, top, nearval, farval);
1210}
1211
1212
1213GLuint GLAPIENTRY glGenLists(CTX_ARG GLsizei range )
1214{
1215 GET_CONTEXT;
1216 CHECK_CONTEXT_RETURN(0);
1217 return (*CC->API.GenLists)(CC, range);
1218}
1219
1220
1221void GLAPIENTRY glGenTextures(CTX_ARG GLsizei n, GLuint *textures )
1222{
1223 GET_CONTEXT;
1224 CHECK_CONTEXT;
1225 (*CC->API.GenTextures)(CC, n, textures);
1226}
1227
1228
1229void GLAPIENTRY glGetBooleanv(CTX_ARG GLenum pname, GLboolean *params )
1230{
1231 GET_CONTEXT;
1232 CHECK_CONTEXT;
1233 (*CC->API.GetBooleanv)(CC, pname, params);
1234}
1235
1236
1237void GLAPIENTRY glGetClipPlane(CTX_ARG GLenum plane, GLdouble *equation )
1238{
1239 GET_CONTEXT;
1240 CHECK_CONTEXT;
1241 (*CC->API.GetClipPlane)(CC, plane, equation);
1242}
1243
1244
1245void GLAPIENTRY glGetDoublev(CTX_ARG GLenum pname, GLdouble *params )
1246{
1247 GET_CONTEXT;
1248 CHECK_CONTEXT;
1249 (*CC->API.GetDoublev)(CC, pname, params);
1250}
1251
1252
1253GLenum GLAPIENTRY glGetError(CTX_VOID )
1254{
1255 GET_CONTEXT;
1256 if (!CC) {
1257 /* No current context */
1258 return (GLenum) GL_NO_ERROR;
1259 }
1260 return (*CC->API.GetError)(CC);
1261}
1262
1263
1264void GLAPIENTRY glGetFloatv(CTX_ARG GLenum pname, GLfloat *params )
1265{
1266 GET_CONTEXT;
1267 CHECK_CONTEXT;
1268 (*CC->API.GetFloatv)(CC, pname, params);
1269}
1270
1271
1272void GLAPIENTRY glGetIntegerv(CTX_ARG GLenum pname, GLint *params )
1273{
1274 GET_CONTEXT;
1275 CHECK_CONTEXT;
1276 (*CC->API.GetIntegerv)(CC, pname, params);
1277}
1278
1279
1280void GLAPIENTRY glGetLightfv(CTX_ARG GLenum light, GLenum pname, GLfloat *params )
1281{
1282 GET_CONTEXT;
1283 CHECK_CONTEXT;
1284 (*CC->API.GetLightfv)(CC, light, pname, params);
1285}
1286
1287
1288void GLAPIENTRY glGetLightiv(CTX_ARG GLenum light, GLenum pname, GLint *params )
1289{
1290 GET_CONTEXT;
1291 CHECK_CONTEXT;
1292 (*CC->API.GetLightiv)(CC, light, pname, params);
1293}
1294
1295
1296void GLAPIENTRY glGetMapdv(CTX_ARG GLenum target, GLenum query, GLdouble *v )
1297{
1298 GET_CONTEXT;
1299 CHECK_CONTEXT;
1300 (*CC->API.GetMapdv)( CC, target, query, v );
1301}
1302
1303
1304void GLAPIENTRY glGetMapfv(CTX_ARG GLenum target, GLenum query, GLfloat *v )
1305{
1306 GET_CONTEXT;
1307 CHECK_CONTEXT;
1308 (*CC->API.GetMapfv)( CC, target, query, v );
1309}
1310
1311
1312void GLAPIENTRY glGetMapiv(CTX_ARG GLenum target, GLenum query, GLint *v )
1313{
1314 GET_CONTEXT;
1315 CHECK_CONTEXT;
1316 (*CC->API.GetMapiv)( CC, target, query, v );
1317}
1318
1319
1320void GLAPIENTRY glGetMaterialfv(CTX_ARG GLenum face, GLenum pname, GLfloat *params )
1321{
1322 GET_CONTEXT;
1323 CHECK_CONTEXT;
1324 (*CC->API.GetMaterialfv)(CC, face, pname, params);
1325}
1326
1327
1328void GLAPIENTRY glGetMaterialiv(CTX_ARG GLenum face, GLenum pname, GLint *params )
1329{
1330 GET_CONTEXT;
1331 CHECK_CONTEXT;
1332 (*CC->API.GetMaterialiv)(CC, face, pname, params);
1333}
1334
1335
1336void GLAPIENTRY glGetPixelMapfv(CTX_ARG GLenum map, GLfloat *values )
1337{
1338 GET_CONTEXT;
1339 CHECK_CONTEXT;
1340 (*CC->API.GetPixelMapfv)(CC, map, values);
1341}
1342
1343
1344void GLAPIENTRY glGetPixelMapuiv(CTX_ARG GLenum map, GLuint *values )
1345{
1346 GET_CONTEXT;
1347 CHECK_CONTEXT;
1348 (*CC->API.GetPixelMapuiv)(CC, map, values);
1349}
1350
1351
1352void GLAPIENTRY glGetPixelMapusv(CTX_ARG GLenum map, GLushort *values )
1353{
1354 GET_CONTEXT;
1355 CHECK_CONTEXT;
1356 (*CC->API.GetPixelMapusv)(CC, map, values);
1357}
1358
1359
1360void GLAPIENTRY glGetPointerv(CTX_ARG GLenum pname, GLvoid **params )
1361{
1362 GET_CONTEXT;
1363 CHECK_CONTEXT;
1364 (*CC->API.GetPointerv)(CC, pname, params);
1365}
1366
1367
1368void GLAPIENTRY glGetPolygonStipple(CTX_ARG GLubyte *mask )
1369{
1370 GET_CONTEXT;
1371 CHECK_CONTEXT;
1372 (*CC->API.GetPolygonStipple)(CC, mask);
1373}
1374
1375
1376const GLubyte * GLAPIENTRY glGetString(CTX_ARG GLenum name )
1377{
1378 GET_CONTEXT;
1379 CHECK_CONTEXT_RETURN(NULL);
1380 /* even check for NULL context when not compiled with -DDEBUG */
1381 if (!CC)
1382 return NULL;
1383 return (*CC->API.GetString)(CC, name);
1384}
1385
1386
1387void GLAPIENTRY glGetTexEnvfv(CTX_ARG GLenum target, GLenum pname, GLfloat *params )
1388{
1389 GET_CONTEXT;
1390 CHECK_CONTEXT;
1391 (*CC->API.GetTexEnvfv)(CC, target, pname, params);
1392}
1393
1394
1395void GLAPIENTRY glGetTexEnviv(CTX_ARG GLenum target, GLenum pname, GLint *params )
1396{
1397 GET_CONTEXT;
1398 CHECK_CONTEXT;
1399 (*CC->API.GetTexEnviv)(CC, target, pname, params);
1400}
1401
1402
1403void GLAPIENTRY glGetTexGeniv(CTX_ARG GLenum coord, GLenum pname, GLint *params )
1404{
1405 GET_CONTEXT;
1406 CHECK_CONTEXT;
1407 (*CC->API.GetTexGeniv)(CC, coord, pname, params);
1408}
1409
1410
1411void GLAPIENTRY glGetTexGendv(CTX_ARG GLenum coord, GLenum pname, GLdouble *params )
1412{
1413 GET_CONTEXT;
1414 CHECK_CONTEXT;
1415 (*CC->API.GetTexGendv)(CC, coord, pname, params);
1416}
1417
1418
1419void GLAPIENTRY glGetTexGenfv(CTX_ARG GLenum coord, GLenum pname, GLfloat *params )
1420{
1421 GET_CONTEXT;
1422 CHECK_CONTEXT;
1423 (*CC->API.GetTexGenfv)(CC, coord, pname, params);
1424}
1425
1426
1427void GLAPIENTRY glGetTexImage(CTX_ARG GLenum target, GLint level, GLenum format,
1428 GLenum type, GLvoid *pixels )
1429{
1430 GET_CONTEXT;
1431 CHECK_CONTEXT;
1432 (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
1433}
1434
1435
1436void GLAPIENTRY glGetTexLevelParameterfv(CTX_ARG GLenum target, GLint level,
1437 GLenum pname, GLfloat *params )
1438{
1439 GET_CONTEXT;
1440 CHECK_CONTEXT;
1441 (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
1442}
1443
1444
1445void GLAPIENTRY glGetTexLevelParameteriv(CTX_ARG GLenum target, GLint level,
1446 GLenum pname, GLint *params )
1447{
1448 GET_CONTEXT;
1449 CHECK_CONTEXT;
1450 (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
1451}
1452
1453
1454void GLAPIENTRY glGetTexParameterfv(CTX_ARG GLenum target, GLenum pname,
1455 GLfloat *params)
1456{
1457 GET_CONTEXT;
1458 CHECK_CONTEXT;
1459 (*CC->API.GetTexParameterfv)(CC, target, pname, params);
1460}
1461
1462
1463void GLAPIENTRY glGetTexParameteriv(CTX_ARG GLenum target, GLenum pname,
1464 GLint *params )
1465{
1466 GET_CONTEXT;
1467 CHECK_CONTEXT;
1468 (*CC->API.GetTexParameteriv)(CC, target, pname, params);
1469}
1470
1471
1472void GLAPIENTRY glHint(CTX_ARG GLenum target, GLenum mode )
1473{
1474 GET_CONTEXT;
1475 CHECK_CONTEXT;
1476 if (mode!=GL_DONT_CARE && mode!=GL_FASTEST && mode!=GL_NICEST)
1477 (*CC->API.Error)( CC, GL_INVALID_ENUM, "glHint(mode)" );
1478 else
1479 (*CC->API.Hint)(CC, target, mode);
1480}
1481
1482
1483#define INDEX( c ) \
1484{ \
1485 GLuint count; \
1486 GET_IMMEDIATE; \
1487 count = IM->Count; \
1488 IM->Index[count] = c; \
1489 IM->Flag[count] |= VERT_INDEX; \
1490}
1491
1492
1493void GLAPIENTRY glIndexd(CTX_ARG GLdouble c )
1494{
1495 INDEX( (GLuint) (GLint) c );
1496}
1497
1498
1499void GLAPIENTRY glIndexf(CTX_ARG GLfloat c )
1500{
1501 INDEX( (GLuint) (GLint) c );
1502}
1503
1504
1505void GLAPIENTRY glIndexi(CTX_ARG GLint c )
1506{
1507 INDEX( (GLuint) c );
1508}
1509
1510
1511void GLAPIENTRY glIndexs(CTX_ARG GLshort c )
1512{
1513 INDEX( (GLuint) c );
1514}
1515
1516
1517/* GL_VERSION_1_1 */
1518void GLAPIENTRY glIndexub(CTX_ARG GLubyte c )
1519{
1520 INDEX( (GLuint) c );
1521}
1522
1523
1524void GLAPIENTRY glIndexdv(CTX_ARG const GLdouble *c )
1525{
1526 INDEX( (GLuint) (GLint) *c );
1527}
1528
1529
1530void GLAPIENTRY glIndexfv(CTX_ARG const GLfloat *c )
1531{
1532 INDEX( (GLuint) (GLint) *c );
1533}
1534
1535
1536void GLAPIENTRY glIndexiv(CTX_ARG const GLint *c )
1537{
1538 INDEX( *c );
1539}
1540
1541
1542void GLAPIENTRY glIndexsv(CTX_ARG const GLshort *c )
1543{
1544 INDEX( (GLuint) (GLint) *c );
1545}
1546
1547
1548/* GL_VERSION_1_1 */
1549void GLAPIENTRY glIndexubv(CTX_ARG const GLubyte *c )
1550{
1551 INDEX( (GLuint) *c );
1552}
1553
1554
1555void GLAPIENTRY glIndexMask(CTX_ARG GLuint mask )
1556{
1557 GET_CONTEXT;
1558 (*CC->API.IndexMask)(CC, mask);
1559}
1560
1561
1562
1563
1564void GLAPIENTRY glInitNames(CTX_VOID )
1565{
1566 GET_CONTEXT;
1567 CHECK_CONTEXT;
1568 (*CC->API.InitNames)(CC);
1569}
1570
1571
1572GLboolean GLAPIENTRY glIsList(CTX_ARG GLuint list )
1573{
1574 GET_CONTEXT;
1575 CHECK_CONTEXT_RETURN(GL_FALSE);
1576 return (*CC->API.IsList)(CC, list);
1577}
1578
1579
1580GLboolean GLAPIENTRY glIsTexture(CTX_ARG GLuint texture )
1581{
1582 GET_CONTEXT;
1583 CHECK_CONTEXT_RETURN(GL_FALSE);
1584 return (*CC->API.IsTexture)(CC, texture);
1585}
1586
1587
1588void GLAPIENTRY glLightf(CTX_ARG GLenum light, GLenum pname, GLfloat param )
1589{
1590 GET_CONTEXT;
1591 CHECK_CONTEXT;
1592 (*CC->API.Lightfv)( CC, light, pname, &param, 1 );
1593}
1594
1595
1596void GLAPIENTRY glLighti(CTX_ARG GLenum light, GLenum pname, GLint param )
1597{
1598 GLfloat fparam = (GLfloat) param;
1599 GET_CONTEXT;
1600 CHECK_CONTEXT;
1601 (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
1602}
1603
1604
1605void GLAPIENTRY glLightfv(CTX_ARG GLenum light, GLenum pname, const GLfloat *params )
1606{
1607 GET_CONTEXT;
1608 CHECK_CONTEXT;
1609 (*CC->API.Lightfv)( CC, light, pname, params, 4 );
1610}
1611
1612
1613void GLAPIENTRY glLightiv(CTX_ARG GLenum light, GLenum pname, const GLint *params )
1614{
1615 GLfloat fparam[4];
1616 GET_CONTEXT;
1617 CHECK_CONTEXT;
1618
1619 switch (pname) {
1620 case GL_AMBIENT:
1621 case GL_DIFFUSE:
1622 case GL_SPECULAR:
1623 fparam[0] = INT_TO_FLOAT( params[0] );
1624 fparam[1] = INT_TO_FLOAT( params[1] );
1625 fparam[2] = INT_TO_FLOAT( params[2] );
1626 fparam[3] = INT_TO_FLOAT( params[3] );
1627 break;
1628 case GL_POSITION:
1629 fparam[0] = (GLfloat) params[0];
1630 fparam[1] = (GLfloat) params[1];
1631 fparam[2] = (GLfloat) params[2];
1632 fparam[3] = (GLfloat) params[3];
1633 break;
1634 case GL_SPOT_DIRECTION:
1635 fparam[0] = (GLfloat) params[0];
1636 fparam[1] = (GLfloat) params[1];
1637 fparam[2] = (GLfloat) params[2];
1638 break;
1639 case GL_SPOT_EXPONENT:
1640 case GL_SPOT_CUTOFF:
1641 case GL_CONSTANT_ATTENUATION:
1642 case GL_LINEAR_ATTENUATION:
1643 case GL_QUADRATIC_ATTENUATION:
1644 fparam[0] = (GLfloat) params[0];
1645 break;
1646 default:
1647 /* error will be caught later in gl_Lightfv */
1648 ;
1649 }
1650 (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
1651}
1652
1653
1654void GLAPIENTRY glLightModelf(CTX_ARG GLenum pname, GLfloat param )
1655{
1656 GET_CONTEXT;
1657 CHECK_CONTEXT;
1658 (*CC->API.LightModelfv)( CC, pname, &param );
1659}
1660
1661
1662void GLAPIENTRY glLightModeli(CTX_ARG GLenum pname, GLint param )
1663{
1664 GLfloat fparam[4];
1665 GET_CONTEXT;
1666 CHECK_CONTEXT;
1667 fparam[0] = (GLfloat) param;
1668 (*CC->API.LightModelfv)( CC, pname, fparam );
1669}
1670
1671
1672void GLAPIENTRY glLightModelfv(CTX_ARG GLenum pname, const GLfloat *params )
1673{
1674 GET_CONTEXT;
1675 CHECK_CONTEXT;
1676 (*CC->API.LightModelfv)( CC, pname, params );
1677}
1678
1679
1680void GLAPIENTRY glLightModeliv(CTX_ARG GLenum pname, const GLint *params )
1681{
1682 GLfloat fparam[4];
1683 GET_CONTEXT;
1684 CHECK_CONTEXT;
1685
1686 switch (pname) {
1687 case GL_LIGHT_MODEL_AMBIENT:
1688 fparam[0] = INT_TO_FLOAT( params[0] );
1689 fparam[1] = INT_TO_FLOAT( params[1] );
1690 fparam[2] = INT_TO_FLOAT( params[2] );
1691 fparam[3] = INT_TO_FLOAT( params[3] );
1692 break;
1693 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1694 case GL_LIGHT_MODEL_TWO_SIDE:
1695 case GL_LIGHT_MODEL_COLOR_CONTROL:
1696 fparam[0] = (GLfloat) params[0];
1697 break;
1698 default:
1699 /* Error will be caught later in gl_LightModelfv */
1700 ;
1701 }
1702 (*CC->API.LightModelfv)( CC, pname, fparam );
1703}
1704
1705
1706void GLAPIENTRY glLineWidth(CTX_ARG GLfloat width )
1707{
1708 GET_CONTEXT;
1709 CHECK_CONTEXT;
1710 (*CC->API.LineWidth)(CC, width);
1711}
1712
1713
1714void GLAPIENTRY glLineStipple(CTX_ARG GLint factor, GLushort pattern )
1715{
1716 GET_CONTEXT;
1717 CHECK_CONTEXT;
1718 (*CC->API.LineStipple)(CC, factor, pattern);
1719}
1720
1721
1722void GLAPIENTRY glListBase(CTX_ARG GLuint base )
1723{
1724 GET_CONTEXT;
1725 CHECK_CONTEXT;
1726 (*CC->API.ListBase)(CC, base);
1727}
1728
1729
1730void GLAPIENTRY glLoadIdentity(CTX_VOID )
1731{
1732 GET_CONTEXT;
1733 CHECK_CONTEXT;
1734 (*CC->API.LoadIdentity)( CC );
1735}
1736
1737
1738void GLAPIENTRY glLoadMatrixd(CTX_ARG const GLdouble *m )
1739{
1740 GLfloat fm[16];
1741 GLuint i;
1742 GET_CONTEXT;
1743 CHECK_CONTEXT;
1744
1745 for (i=0;i<16;i++) {
1746 fm[i] = (GLfloat) m[i];
1747 }
1748
1749 (*CC->API.LoadMatrixf)( CC, fm );
1750}
1751
1752
1753void GLAPIENTRY glLoadMatrixf(CTX_ARG const GLfloat *m )
1754{
1755 GET_CONTEXT;
1756 CHECK_CONTEXT;
1757 (*CC->API.LoadMatrixf)( CC, m );
1758}
1759
1760
1761void GLAPIENTRY glLoadName(CTX_ARG GLuint name )
1762{
1763 GET_CONTEXT;
1764 CHECK_CONTEXT;
1765 (*CC->API.LoadName)(CC, name);
1766}
1767
1768
1769void GLAPIENTRY glLogicOp(CTX_ARG GLenum opcode )
1770{
1771 GET_CONTEXT;
1772 CHECK_CONTEXT;
1773 (*CC->API.LogicOp)(CC, opcode);
1774}
1775
1776
1777
1778void GLAPIENTRY glMap1d(CTX_ARG GLenum target, GLdouble u1, GLdouble u2, GLint stride,
1779 GLint order, const GLdouble *points )
1780{
1781 GLfloat *pnts;
1782 GLboolean retain;
1783 GET_CONTEXT;
1784 CHECK_CONTEXT;
1785
1786 pnts = gl_copy_map_points1d( target, stride, order, points );
1787 retain = CC->CompileFlag;
1788 (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
1789}
1790
1791
1792void GLAPIENTRY glMap1f(CTX_ARG GLenum target, GLfloat u1, GLfloat u2, GLint stride,
1793 GLint order, const GLfloat *points )
1794{
1795 GLfloat *pnts;
1796 GLboolean retain;
1797 GET_CONTEXT;
1798 CHECK_CONTEXT;
1799
1800 pnts = gl_copy_map_points1f( target, stride, order, points );
1801 retain = CC->CompileFlag;
1802 (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
1803}
1804
1805
1806void GLAPIENTRY glMap2d(CTX_ARG GLenum target,
1807 GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
1808 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
1809 const GLdouble *points )
1810{
1811 GLfloat *pnts;
1812 GLboolean retain;
1813 GET_CONTEXT;
1814 CHECK_CONTEXT;
1815
1816 pnts = gl_copy_map_points2d( target, ustride, uorder,
1817 vstride, vorder, points );
1818 retain = CC->CompileFlag;
1819 (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
1820 v1, v2, vstride, vorder, pnts, retain );
1821}
1822
1823
1824void GLAPIENTRY glMap2f(CTX_ARG GLenum target,
1825 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
1826 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
1827 const GLfloat *points )
1828{
1829 GLfloat *pnts;
1830 GLboolean retain;
1831 GET_CONTEXT;
1832 CHECK_CONTEXT;
1833
1834 pnts = gl_copy_map_points2f( target, ustride, uorder,
1835 vstride, vorder, points );
1836 retain = CC->CompileFlag;
1837 (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
1838 v1, v2, vstride, vorder, pnts, retain );
1839}
1840
1841
1842void GLAPIENTRY glMapGrid1d(CTX_ARG GLint un, GLdouble u1, GLdouble u2 )
1843{
1844 GET_CONTEXT;
1845 CHECK_CONTEXT;
1846 (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
1847}
1848
1849
1850void GLAPIENTRY glMapGrid1f(CTX_ARG GLint un, GLfloat u1, GLfloat u2 )
1851{
1852 GET_CONTEXT;
1853 CHECK_CONTEXT;
1854 (*CC->API.MapGrid1f)( CC, un, u1, u2 );
1855}
1856
1857
1858void GLAPIENTRY glMapGrid2d(CTX_ARG GLint un, GLdouble u1, GLdouble u2,
1859 GLint vn, GLdouble v1, GLdouble v2 )
1860{
1861 GET_CONTEXT;
1862 CHECK_CONTEXT;
1863 (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
1864 vn, (GLfloat) v1, (GLfloat) v2 );
1865}
1866
1867
1868void GLAPIENTRY glMapGrid2f(CTX_ARG GLint un, GLfloat u1, GLfloat u2,
1869 GLint vn, GLfloat v1, GLfloat v2 )
1870{
1871 GET_CONTEXT;
1872 CHECK_CONTEXT;
1873 (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
1874}
1875
1876
1877void GLAPIENTRY glMaterialf(CTX_ARG GLenum face, GLenum pname, GLfloat param )
1878{
1879 GET_CONTEXT;
1880 CHECK_CONTEXT;
1881 gl_Materialfv( CC, face, pname, &param );
1882}
1883
1884
1885
1886void GLAPIENTRY glMateriali(CTX_ARG GLenum face, GLenum pname, GLint param )
1887{
1888 GLfloat fparam[4];
1889 GET_CONTEXT;
1890 CHECK_CONTEXT;
1891 fparam[0] = (GLfloat) param;
1892 gl_Materialfv( CC, face, pname, fparam );
1893}
1894
1895
1896void GLAPIENTRY glMaterialfv(CTX_ARG GLenum face, GLenum pname, const GLfloat *params )
1897{
1898 GET_CONTEXT;
1899 CHECK_CONTEXT;
1900 gl_Materialfv( CC, face, pname, params );
1901}
1902
1903
1904void GLAPIENTRY glMaterialiv(CTX_ARG GLenum face, GLenum pname, const GLint *params )
1905{
1906 GLfloat fparam[4];
1907 GET_CONTEXT;
1908 CHECK_CONTEXT;
1909 switch (pname) {
1910 case GL_AMBIENT:
1911 case GL_DIFFUSE:
1912 case GL_SPECULAR:
1913 case GL_EMISSION:
1914 case GL_AMBIENT_AND_DIFFUSE:
1915 fparam[0] = INT_TO_FLOAT( params[0] );
1916 fparam[1] = INT_TO_FLOAT( params[1] );
1917 fparam[2] = INT_TO_FLOAT( params[2] );
1918 fparam[3] = INT_TO_FLOAT( params[3] );
1919 break;
1920 case GL_SHININESS:
1921 fparam[0] = (GLfloat) params[0];
1922 break;
1923 case GL_COLOR_INDEXES:
1924 fparam[0] = (GLfloat) params[0];
1925 fparam[1] = (GLfloat) params[1];
1926 fparam[2] = (GLfloat) params[2];
1927 break;
1928 default:
1929 /* Error will be caught later in gl_Materialfv */
1930 ;
1931 }
1932 gl_Materialfv( CC, face, pname, fparam );
1933}
1934
1935
1936void GLAPIENTRY glMatrixMode(CTX_ARG GLenum mode )
1937{
1938 GET_CONTEXT;
1939 CHECK_CONTEXT;
1940 (*CC->API.MatrixMode)( CC, mode );
1941}
1942
1943
1944void GLAPIENTRY glMultMatrixd(CTX_ARG const GLdouble *m )
1945{
1946 GLfloat fm[16];
1947 GLuint i;
1948 GET_CONTEXT;
1949 CHECK_CONTEXT;
1950
1951 for (i=0;i<16;i++) {
1952 fm[i] = (GLfloat) m[i];
1953 }
1954
1955 (*CC->API.MultMatrixf)( CC, fm );
1956}
1957
1958
1959void GLAPIENTRY glMultMatrixf(CTX_ARG const GLfloat *m )
1960{
1961 GET_CONTEXT;
1962 CHECK_CONTEXT;
1963 (*CC->API.MultMatrixf)( CC, m );
1964}
1965
1966
1967void GLAPIENTRY glNewList(CTX_ARG GLuint list, GLenum mode )
1968{
1969 GET_CONTEXT;
1970 CHECK_CONTEXT;
1971 (*CC->API.NewList)(CC, list, mode);
1972}
1973
1974
1975/* KW: Now that we build buffers for display lists the same way we
1976 * fill the vb, we can do the work here without a second function
1977 * call. The Flag member allows the identification of missing
1978 * (ie shared) normals.
1979 */
1980#define NORMAL( x,y,z ) \
1981{ \
1982 GLuint count; \
1983 GLfloat *normal; \
1984 GET_IMMEDIATE; \
1985 count = IM->Count; \
1986 IM->Flag[count] |= VERT_NORM; \
1987 normal = IM->Normal[count]; \
1988 ASSIGN_3V(normal, x,y,z); \
1989}
1990
1991
1992void GLAPIENTRY glNormal3b(CTX_ARG GLbyte nx, GLbyte ny, GLbyte nz )
1993{
1994 NORMAL( BYTE_TO_FLOAT(nx),
1995 BYTE_TO_FLOAT(ny),
1996 BYTE_TO_FLOAT(nz) );
1997}
1998
1999
2000void GLAPIENTRY glNormal3d(CTX_ARG GLdouble nx, GLdouble ny, GLdouble nz )
2001{
2002 NORMAL(nx,ny,nz);
2003}
2004
2005
2006void GLAPIENTRY glNormal3f(CTX_ARG GLfloat nx, GLfloat ny, GLfloat nz )
2007{
2008 NORMAL(nx,ny,nz);
2009}
2010
2011
2012void GLAPIENTRY glNormal3i(CTX_ARG GLint nx, GLint ny, GLint nz )
2013{
2014 NORMAL( INT_TO_FLOAT(nx),
2015 INT_TO_FLOAT(ny),
2016 INT_TO_FLOAT(nz) );
2017}
2018
2019
2020void GLAPIENTRY glNormal3s(CTX_ARG GLshort nx, GLshort ny, GLshort nz )
2021{
2022 NORMAL( SHORT_TO_FLOAT(nx),
2023 SHORT_TO_FLOAT(ny),
2024 SHORT_TO_FLOAT(nz) );
2025}
2026
2027
2028void GLAPIENTRY glNormal3bv(CTX_ARG const GLbyte *v )
2029{
2030 NORMAL( BYTE_TO_FLOAT(v[0]),
2031 BYTE_TO_FLOAT(v[1]),
2032 BYTE_TO_FLOAT(v[2]) );
2033}
2034
2035
2036void GLAPIENTRY glNormal3dv(CTX_ARG const GLdouble *v )
2037{
2038 NORMAL( v[0], v[1], v[2] );
2039}
2040
2041
2042void GLAPIENTRY glNormal3fv(CTX_ARG const GLfloat *v )
2043{
2044 NORMAL( v[0], v[1], v[2] );
2045}
2046
2047
2048void GLAPIENTRY glNormal3iv(CTX_ARG const GLint *v )
2049{
2050 NORMAL( INT_TO_FLOAT(v[0]),
2051 INT_TO_FLOAT(v[1]),
2052 INT_TO_FLOAT(v[2]) );
2053}
2054
2055
2056void GLAPIENTRY glNormal3sv(CTX_ARG const GLshort *v )
2057{
2058 NORMAL( SHORT_TO_FLOAT(v[0]),
2059 SHORT_TO_FLOAT(v[1]),
2060 SHORT_TO_FLOAT(v[2]) );
2061}
2062
Note: See TracBrowser for help on using the repository browser.