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

Last change on this file since 3597 was 3081, checked in by sandervl, 25 years ago

compile fix
File size: 47.6 KB
Line 
1/* $Id: api1.c,v 1.4 2000-03-11 13:54:25 sandervl 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 if (count == VB_MAX-1) \
969 IM->maybe_transform_vb( IM ); \
970}
971
972#define EVALPOINT1(IM, x) \
973{ \
974 GLuint count = IM->Count++; \
975 IM->Flag[count] |= VERT_EVAL_P1; \
976 ASSIGN_4V(IM->Obj[count], x, 0, 0, 1); \
977 if (count == VB_MAX-1) \
978 IM->maybe_transform_vb( IM ); \
979}
980
981#define EVALPOINT2(IM, x, y) \
982{ \
983 GLuint count = IM->Count++; \
984 IM->Flag[count] |= VERT_EVAL_P2; \
985 ASSIGN_4V(IM->Obj[count], x, y, 0, 1); \
986 if (count == VB_MAX-1) \
987 IM->maybe_transform_vb( IM ); \
988}
989
990
991void GLAPIENTRY glEvalCoord1d(CTX_ARG GLdouble u )
992{
993 GET_IMMEDIATE;
994 EVALCOORD1( IM, (GLfloat) u );
995}
996
997
998void GLAPIENTRY glEvalCoord1f(CTX_ARG GLfloat u )
999{
1000 GET_IMMEDIATE;
1001 EVALCOORD1( IM, u );
1002}
1003
1004
1005/* Lame internal function:
1006 */
1007void gl_EvalCoord1f( GLcontext *CC, GLfloat u )
1008{
1009 struct immediate *i = CC->input;
1010 EVALCOORD1( i, u );
1011}
1012
1013
1014void GLAPIENTRY glEvalCoord1dv(CTX_ARG const GLdouble *u )
1015{
1016 GET_IMMEDIATE;
1017 EVALCOORD1( IM, (GLfloat) *u );
1018}
1019
1020
1021void GLAPIENTRY glEvalCoord1fv(CTX_ARG const GLfloat *u )
1022{
1023 GET_IMMEDIATE;
1024 EVALCOORD1( IM, (GLfloat) *u );
1025}
1026
1027
1028void GLAPIENTRY glEvalCoord2d(CTX_ARG GLdouble u, GLdouble v )
1029{
1030 GET_IMMEDIATE;
1031 EVALCOORD2( IM, (GLfloat) u, (GLfloat) v );
1032}
1033
1034
1035void GLAPIENTRY glEvalCoord2f(CTX_ARG GLfloat u, GLfloat v )
1036{
1037 GET_IMMEDIATE;
1038 EVALCOORD2( IM, u, v );
1039}
1040
1041
1042/* Lame internal function:
1043 */
1044void gl_EvalCoord2f( GLcontext *CC, GLfloat u, GLfloat v )
1045{
1046 struct immediate *i = CC->input;
1047 EVALCOORD2( i, u, v );
1048}
1049
1050
1051void GLAPIENTRY glEvalCoord2dv(CTX_ARG const GLdouble *u )
1052{
1053 GET_IMMEDIATE;
1054 EVALCOORD2( IM, (GLfloat) u[0], (GLfloat) u[1] );
1055}
1056
1057
1058void GLAPIENTRY glEvalCoord2fv(CTX_ARG const GLfloat *u )
1059{
1060 GET_IMMEDIATE;
1061 EVALCOORD2( IM, u[0], u[1] );
1062}
1063
1064
1065void GLAPIENTRY glEvalPoint1(CTX_ARG GLint i )
1066{
1067 GET_IMMEDIATE;
1068 EVALPOINT1( IM, i );
1069}
1070
1071
1072void GLAPIENTRY glEvalPoint2(CTX_ARG GLint i, GLint j )
1073{
1074 GET_IMMEDIATE;
1075 EVALPOINT2( IM, i, j );
1076}
1077
1078
1079void GLAPIENTRY glEvalMesh1(CTX_ARG GLenum mode, GLint i1, GLint i2 )
1080{
1081 GET_CONTEXT;
1082 CHECK_CONTEXT;
1083 (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
1084}
1085
1086
1087void GLAPIENTRY glEdgeFlag(CTX_ARG GLboolean flag )
1088{
1089 GLuint count;
1090 GET_IMMEDIATE;
1091 count = IM->Count;
1092 IM->EdgeFlag[count] = flag;
1093 IM->Flag[count] |= VERT_EDGE;
1094}
1095
1096
1097void GLAPIENTRY glEdgeFlagv(CTX_ARG const GLboolean *flag )
1098{
1099 GLuint count;
1100 GET_IMMEDIATE;
1101 count = IM->Count;
1102 IM->EdgeFlag[count] = *flag;
1103 IM->Flag[count] |= VERT_EDGE;
1104}
1105
1106
1107
1108void GLAPIENTRY glEvalMesh2(CTX_ARG GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
1109{
1110 GET_CONTEXT;
1111 CHECK_CONTEXT;
1112 (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
1113}
1114
1115
1116void GLAPIENTRY glFeedbackBuffer(CTX_ARG GLsizei size, GLenum type, GLfloat *buffer )
1117{
1118 GET_CONTEXT;
1119 CHECK_CONTEXT;
1120 (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
1121}
1122
1123
1124void GLAPIENTRY glFinish(CTX_VOID )
1125{
1126 GET_CONTEXT;
1127 CHECK_CONTEXT;
1128 (*CC->API.Finish)(CC);
1129}
1130
1131
1132void GLAPIENTRY glFlush(CTX_VOID )
1133{
1134 GET_CONTEXT;
1135 CHECK_CONTEXT;
1136 (*CC->API.Flush)(CC);
1137}
1138
1139
1140void GLAPIENTRY glFogf(CTX_ARG GLenum pname, GLfloat param )
1141{
1142 GET_CONTEXT;
1143 CHECK_CONTEXT;
1144 (*CC->API.Fogfv)(CC, pname, &param);
1145}
1146
1147
1148void GLAPIENTRY glFogi(CTX_ARG GLenum pname, GLint param )
1149{
1150 GLfloat fparam = (GLfloat) param;
1151 GET_CONTEXT;
1152 CHECK_CONTEXT;
1153 (*CC->API.Fogfv)(CC, pname, &fparam);
1154}
1155
1156
1157void GLAPIENTRY glFogfv(CTX_ARG GLenum pname, const GLfloat *params )
1158{
1159 GET_CONTEXT;
1160 CHECK_CONTEXT;
1161 (*CC->API.Fogfv)(CC, pname, params);
1162}
1163
1164
1165void GLAPIENTRY glFogiv(CTX_ARG GLenum pname, const GLint *params )
1166{
1167 GLfloat p[4];
1168 GET_CONTEXT;
1169 CHECK_CONTEXT;
1170
1171 switch (pname) {
1172 case GL_FOG_MODE:
1173 case GL_FOG_DENSITY:
1174 case GL_FOG_START:
1175 case GL_FOG_END:
1176 case GL_FOG_INDEX:
1177 p[0] = (GLfloat) *params;
1178 break;
1179 case GL_FOG_COLOR:
1180 p[0] = INT_TO_FLOAT( params[0] );
1181 p[1] = INT_TO_FLOAT( params[1] );
1182 p[2] = INT_TO_FLOAT( params[2] );
1183 p[3] = INT_TO_FLOAT( params[3] );
1184 break;
1185 default:
1186 /* Error will be caught later in gl_Fogfv */
1187 ;
1188 }
1189 (*CC->API.Fogfv)( CC, pname, p );
1190}
1191
1192
1193void GLAPIENTRY glFrontFace(CTX_ARG GLenum mode )
1194{
1195 GET_CONTEXT;
1196 CHECK_CONTEXT;
1197 (*CC->API.FrontFace)(CC, mode);
1198}
1199
1200
1201void GLAPIENTRY glFrustum(CTX_ARG GLdouble left, GLdouble right,
1202 GLdouble bottom, GLdouble top,
1203 GLdouble nearval, GLdouble farval )
1204{
1205 GET_CONTEXT;
1206 CHECK_CONTEXT;
1207 (*CC->API.Frustum)(CC, left, right, bottom, top, nearval, farval);
1208}
1209
1210
1211GLuint GLAPIENTRY glGenLists(CTX_ARG GLsizei range )
1212{
1213 GET_CONTEXT;
1214 CHECK_CONTEXT_RETURN(0);
1215 return (*CC->API.GenLists)(CC, range);
1216}
1217
1218
1219void GLAPIENTRY glGenTextures(CTX_ARG GLsizei n, GLuint *textures )
1220{
1221 GET_CONTEXT;
1222 CHECK_CONTEXT;
1223 (*CC->API.GenTextures)(CC, n, textures);
1224}
1225
1226
1227void GLAPIENTRY glGetBooleanv(CTX_ARG GLenum pname, GLboolean *params )
1228{
1229 GET_CONTEXT;
1230 CHECK_CONTEXT;
1231 (*CC->API.GetBooleanv)(CC, pname, params);
1232}
1233
1234
1235void GLAPIENTRY glGetClipPlane(CTX_ARG GLenum plane, GLdouble *equation )
1236{
1237 GET_CONTEXT;
1238 CHECK_CONTEXT;
1239 (*CC->API.GetClipPlane)(CC, plane, equation);
1240}
1241
1242
1243void GLAPIENTRY glGetDoublev(CTX_ARG GLenum pname, GLdouble *params )
1244{
1245 GET_CONTEXT;
1246 CHECK_CONTEXT;
1247 (*CC->API.GetDoublev)(CC, pname, params);
1248}
1249
1250
1251GLenum GLAPIENTRY glGetError(CTX_VOID )
1252{
1253 GET_CONTEXT;
1254 if (!CC) {
1255 /* No current context */
1256 return (GLenum) GL_NO_ERROR;
1257 }
1258 return (*CC->API.GetError)(CC);
1259}
1260
1261
1262void GLAPIENTRY glGetFloatv(CTX_ARG GLenum pname, GLfloat *params )
1263{
1264 GET_CONTEXT;
1265 CHECK_CONTEXT;
1266 (*CC->API.GetFloatv)(CC, pname, params);
1267}
1268
1269
1270void GLAPIENTRY glGetIntegerv(CTX_ARG GLenum pname, GLint *params )
1271{
1272 GET_CONTEXT;
1273 CHECK_CONTEXT;
1274 (*CC->API.GetIntegerv)(CC, pname, params);
1275}
1276
1277
1278void GLAPIENTRY glGetLightfv(CTX_ARG GLenum light, GLenum pname, GLfloat *params )
1279{
1280 GET_CONTEXT;
1281 CHECK_CONTEXT;
1282 (*CC->API.GetLightfv)(CC, light, pname, params);
1283}
1284
1285
1286void GLAPIENTRY glGetLightiv(CTX_ARG GLenum light, GLenum pname, GLint *params )
1287{
1288 GET_CONTEXT;
1289 CHECK_CONTEXT;
1290 (*CC->API.GetLightiv)(CC, light, pname, params);
1291}
1292
1293
1294void GLAPIENTRY glGetMapdv(CTX_ARG GLenum target, GLenum query, GLdouble *v )
1295{
1296 GET_CONTEXT;
1297 CHECK_CONTEXT;
1298 (*CC->API.GetMapdv)( CC, target, query, v );
1299}
1300
1301
1302void GLAPIENTRY glGetMapfv(CTX_ARG GLenum target, GLenum query, GLfloat *v )
1303{
1304 GET_CONTEXT;
1305 CHECK_CONTEXT;
1306 (*CC->API.GetMapfv)( CC, target, query, v );
1307}
1308
1309
1310void GLAPIENTRY glGetMapiv(CTX_ARG GLenum target, GLenum query, GLint *v )
1311{
1312 GET_CONTEXT;
1313 CHECK_CONTEXT;
1314 (*CC->API.GetMapiv)( CC, target, query, v );
1315}
1316
1317
1318void GLAPIENTRY glGetMaterialfv(CTX_ARG GLenum face, GLenum pname, GLfloat *params )
1319{
1320 GET_CONTEXT;
1321 CHECK_CONTEXT;
1322 (*CC->API.GetMaterialfv)(CC, face, pname, params);
1323}
1324
1325
1326void GLAPIENTRY glGetMaterialiv(CTX_ARG GLenum face, GLenum pname, GLint *params )
1327{
1328 GET_CONTEXT;
1329 CHECK_CONTEXT;
1330 (*CC->API.GetMaterialiv)(CC, face, pname, params);
1331}
1332
1333
1334void GLAPIENTRY glGetPixelMapfv(CTX_ARG GLenum map, GLfloat *values )
1335{
1336 GET_CONTEXT;
1337 CHECK_CONTEXT;
1338 (*CC->API.GetPixelMapfv)(CC, map, values);
1339}
1340
1341
1342void GLAPIENTRY glGetPixelMapuiv(CTX_ARG GLenum map, GLuint *values )
1343{
1344 GET_CONTEXT;
1345 CHECK_CONTEXT;
1346 (*CC->API.GetPixelMapuiv)(CC, map, values);
1347}
1348
1349
1350void GLAPIENTRY glGetPixelMapusv(CTX_ARG GLenum map, GLushort *values )
1351{
1352 GET_CONTEXT;
1353 CHECK_CONTEXT;
1354 (*CC->API.GetPixelMapusv)(CC, map, values);
1355}
1356
1357
1358void GLAPIENTRY glGetPointerv(CTX_ARG GLenum pname, GLvoid **params )
1359{
1360 GET_CONTEXT;
1361 CHECK_CONTEXT;
1362 (*CC->API.GetPointerv)(CC, pname, params);
1363}
1364
1365
1366void GLAPIENTRY glGetPolygonStipple(CTX_ARG GLubyte *mask )
1367{
1368 GET_CONTEXT;
1369 CHECK_CONTEXT;
1370 (*CC->API.GetPolygonStipple)(CC, mask);
1371}
1372
1373
1374const GLubyte * GLAPIENTRY glGetString(CTX_ARG GLenum name )
1375{
1376 GET_CONTEXT;
1377 CHECK_CONTEXT_RETURN(NULL);
1378 /* even check for NULL context when not compiled with -DDEBUG */
1379 if (!CC)
1380 return NULL;
1381 return (*CC->API.GetString)(CC, name);
1382}
1383
1384
1385void GLAPIENTRY glGetTexEnvfv(CTX_ARG GLenum target, GLenum pname, GLfloat *params )
1386{
1387 GET_CONTEXT;
1388 CHECK_CONTEXT;
1389 (*CC->API.GetTexEnvfv)(CC, target, pname, params);
1390}
1391
1392
1393void GLAPIENTRY glGetTexEnviv(CTX_ARG GLenum target, GLenum pname, GLint *params )
1394{
1395 GET_CONTEXT;
1396 CHECK_CONTEXT;
1397 (*CC->API.GetTexEnviv)(CC, target, pname, params);
1398}
1399
1400
1401void GLAPIENTRY glGetTexGeniv(CTX_ARG GLenum coord, GLenum pname, GLint *params )
1402{
1403 GET_CONTEXT;
1404 CHECK_CONTEXT;
1405 (*CC->API.GetTexGeniv)(CC, coord, pname, params);
1406}
1407
1408
1409void GLAPIENTRY glGetTexGendv(CTX_ARG GLenum coord, GLenum pname, GLdouble *params )
1410{
1411 GET_CONTEXT;
1412 CHECK_CONTEXT;
1413 (*CC->API.GetTexGendv)(CC, coord, pname, params);
1414}
1415
1416
1417void GLAPIENTRY glGetTexGenfv(CTX_ARG GLenum coord, GLenum pname, GLfloat *params )
1418{
1419 GET_CONTEXT;
1420 CHECK_CONTEXT;
1421 (*CC->API.GetTexGenfv)(CC, coord, pname, params);
1422}
1423
1424
1425void GLAPIENTRY glGetTexImage(CTX_ARG GLenum target, GLint level, GLenum format,
1426 GLenum type, GLvoid *pixels )
1427{
1428 GET_CONTEXT;
1429 CHECK_CONTEXT;
1430 (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
1431}
1432
1433
1434void GLAPIENTRY glGetTexLevelParameterfv(CTX_ARG GLenum target, GLint level,
1435 GLenum pname, GLfloat *params )
1436{
1437 GET_CONTEXT;
1438 CHECK_CONTEXT;
1439 (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
1440}
1441
1442
1443void GLAPIENTRY glGetTexLevelParameteriv(CTX_ARG GLenum target, GLint level,
1444 GLenum pname, GLint *params )
1445{
1446 GET_CONTEXT;
1447 CHECK_CONTEXT;
1448 (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
1449}
1450
1451
1452void GLAPIENTRY glGetTexParameterfv(CTX_ARG GLenum target, GLenum pname,
1453 GLfloat *params)
1454{
1455 GET_CONTEXT;
1456 CHECK_CONTEXT;
1457 (*CC->API.GetTexParameterfv)(CC, target, pname, params);
1458}
1459
1460
1461void GLAPIENTRY glGetTexParameteriv(CTX_ARG GLenum target, GLenum pname,
1462 GLint *params )
1463{
1464 GET_CONTEXT;
1465 CHECK_CONTEXT;
1466 (*CC->API.GetTexParameteriv)(CC, target, pname, params);
1467}
1468
1469
1470void GLAPIENTRY glHint(CTX_ARG GLenum target, GLenum mode )
1471{
1472 GET_CONTEXT;
1473 CHECK_CONTEXT;
1474 if (mode!=GL_DONT_CARE && mode!=GL_FASTEST && mode!=GL_NICEST)
1475 (*CC->API.Error)( CC, GL_INVALID_ENUM, "glHint(mode)" );
1476 else
1477 (*CC->API.Hint)(CC, target, mode);
1478}
1479
1480
1481#define INDEX( c ) \
1482{ \
1483 GLuint count; \
1484 GET_IMMEDIATE; \
1485 count = IM->Count; \
1486 IM->Index[count] = c; \
1487 IM->Flag[count] |= VERT_INDEX; \
1488}
1489
1490
1491void GLAPIENTRY glIndexd(CTX_ARG GLdouble c )
1492{
1493 INDEX( (GLuint) (GLint) c );
1494}
1495
1496
1497void GLAPIENTRY glIndexf(CTX_ARG GLfloat c )
1498{
1499 INDEX( (GLuint) (GLint) c );
1500}
1501
1502
1503void GLAPIENTRY glIndexi(CTX_ARG GLint c )
1504{
1505 INDEX( (GLuint) c );
1506}
1507
1508
1509void GLAPIENTRY glIndexs(CTX_ARG GLshort c )
1510{
1511 INDEX( (GLuint) c );
1512}
1513
1514
1515/* GL_VERSION_1_1 */
1516void GLAPIENTRY glIndexub(CTX_ARG GLubyte c )
1517{
1518 INDEX( (GLuint) c );
1519}
1520
1521
1522void GLAPIENTRY glIndexdv(CTX_ARG const GLdouble *c )
1523{
1524 INDEX( (GLuint) (GLint) *c );
1525}
1526
1527
1528void GLAPIENTRY glIndexfv(CTX_ARG const GLfloat *c )
1529{
1530 INDEX( (GLuint) (GLint) *c );
1531}
1532
1533
1534void GLAPIENTRY glIndexiv(CTX_ARG const GLint *c )
1535{
1536 INDEX( *c );
1537}
1538
1539
1540void GLAPIENTRY glIndexsv(CTX_ARG const GLshort *c )
1541{
1542 INDEX( (GLuint) (GLint) *c );
1543}
1544
1545
1546/* GL_VERSION_1_1 */
1547void GLAPIENTRY glIndexubv(CTX_ARG const GLubyte *c )
1548{
1549 INDEX( (GLuint) *c );
1550}
1551
1552
1553void GLAPIENTRY glIndexMask(CTX_ARG GLuint mask )
1554{
1555 GET_CONTEXT;
1556 (*CC->API.IndexMask)(CC, mask);
1557}
1558
1559
1560
1561
1562void GLAPIENTRY glInitNames(CTX_VOID )
1563{
1564 GET_CONTEXT;
1565 CHECK_CONTEXT;
1566 (*CC->API.InitNames)(CC);
1567}
1568
1569
1570GLboolean GLAPIENTRY glIsList(CTX_ARG GLuint list )
1571{
1572 GET_CONTEXT;
1573 CHECK_CONTEXT_RETURN(GL_FALSE);
1574 return (*CC->API.IsList)(CC, list);
1575}
1576
1577
1578GLboolean GLAPIENTRY glIsTexture(CTX_ARG GLuint texture )
1579{
1580 GET_CONTEXT;
1581 CHECK_CONTEXT_RETURN(GL_FALSE);
1582 return (*CC->API.IsTexture)(CC, texture);
1583}
1584
1585
1586void GLAPIENTRY glLightf(CTX_ARG GLenum light, GLenum pname, GLfloat param )
1587{
1588 GET_CONTEXT;
1589 CHECK_CONTEXT;
1590 (*CC->API.Lightfv)( CC, light, pname, &param, 1 );
1591}
1592
1593
1594void GLAPIENTRY glLighti(CTX_ARG GLenum light, GLenum pname, GLint param )
1595{
1596 GLfloat fparam = (GLfloat) param;
1597 GET_CONTEXT;
1598 CHECK_CONTEXT;
1599 (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
1600}
1601
1602
1603void GLAPIENTRY glLightfv(CTX_ARG GLenum light, GLenum pname, const GLfloat *params )
1604{
1605 GET_CONTEXT;
1606 CHECK_CONTEXT;
1607 (*CC->API.Lightfv)( CC, light, pname, params, 4 );
1608}
1609
1610
1611void GLAPIENTRY glLightiv(CTX_ARG GLenum light, GLenum pname, const GLint *params )
1612{
1613 GLfloat fparam[4];
1614 GET_CONTEXT;
1615 CHECK_CONTEXT;
1616
1617 switch (pname) {
1618 case GL_AMBIENT:
1619 case GL_DIFFUSE:
1620 case GL_SPECULAR:
1621 fparam[0] = INT_TO_FLOAT( params[0] );
1622 fparam[1] = INT_TO_FLOAT( params[1] );
1623 fparam[2] = INT_TO_FLOAT( params[2] );
1624 fparam[3] = INT_TO_FLOAT( params[3] );
1625 break;
1626 case GL_POSITION:
1627 fparam[0] = (GLfloat) params[0];
1628 fparam[1] = (GLfloat) params[1];
1629 fparam[2] = (GLfloat) params[2];
1630 fparam[3] = (GLfloat) params[3];
1631 break;
1632 case GL_SPOT_DIRECTION:
1633 fparam[0] = (GLfloat) params[0];
1634 fparam[1] = (GLfloat) params[1];
1635 fparam[2] = (GLfloat) params[2];
1636 break;
1637 case GL_SPOT_EXPONENT:
1638 case GL_SPOT_CUTOFF:
1639 case GL_CONSTANT_ATTENUATION:
1640 case GL_LINEAR_ATTENUATION:
1641 case GL_QUADRATIC_ATTENUATION:
1642 fparam[0] = (GLfloat) params[0];
1643 break;
1644 default:
1645 /* error will be caught later in gl_Lightfv */
1646 ;
1647 }
1648 (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
1649}
1650
1651
1652void GLAPIENTRY glLightModelf(CTX_ARG GLenum pname, GLfloat param )
1653{
1654 GET_CONTEXT;
1655 CHECK_CONTEXT;
1656 (*CC->API.LightModelfv)( CC, pname, &param );
1657}
1658
1659
1660void GLAPIENTRY glLightModeli(CTX_ARG GLenum pname, GLint param )
1661{
1662 GLfloat fparam[4];
1663 GET_CONTEXT;
1664 CHECK_CONTEXT;
1665 fparam[0] = (GLfloat) param;
1666 (*CC->API.LightModelfv)( CC, pname, fparam );
1667}
1668
1669
1670void GLAPIENTRY glLightModelfv(CTX_ARG GLenum pname, const GLfloat *params )
1671{
1672 GET_CONTEXT;
1673 CHECK_CONTEXT;
1674 (*CC->API.LightModelfv)( CC, pname, params );
1675}
1676
1677
1678void GLAPIENTRY glLightModeliv(CTX_ARG GLenum pname, const GLint *params )
1679{
1680 GLfloat fparam[4];
1681 GET_CONTEXT;
1682 CHECK_CONTEXT;
1683
1684 switch (pname) {
1685 case GL_LIGHT_MODEL_AMBIENT:
1686 fparam[0] = INT_TO_FLOAT( params[0] );
1687 fparam[1] = INT_TO_FLOAT( params[1] );
1688 fparam[2] = INT_TO_FLOAT( params[2] );
1689 fparam[3] = INT_TO_FLOAT( params[3] );
1690 break;
1691 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1692 case GL_LIGHT_MODEL_TWO_SIDE:
1693 case GL_LIGHT_MODEL_COLOR_CONTROL:
1694 fparam[0] = (GLfloat) params[0];
1695 break;
1696 default:
1697 /* Error will be caught later in gl_LightModelfv */
1698 ;
1699 }
1700 (*CC->API.LightModelfv)( CC, pname, fparam );
1701}
1702
1703
1704void GLAPIENTRY glLineWidth(CTX_ARG GLfloat width )
1705{
1706 GET_CONTEXT;
1707 CHECK_CONTEXT;
1708 (*CC->API.LineWidth)(CC, width);
1709}
1710
1711
1712void GLAPIENTRY glLineStipple(CTX_ARG GLint factor, GLushort pattern )
1713{
1714 GET_CONTEXT;
1715 CHECK_CONTEXT;
1716 (*CC->API.LineStipple)(CC, factor, pattern);
1717}
1718
1719
1720void GLAPIENTRY glListBase(CTX_ARG GLuint base )
1721{
1722 GET_CONTEXT;
1723 CHECK_CONTEXT;
1724 (*CC->API.ListBase)(CC, base);
1725}
1726
1727
1728void GLAPIENTRY glLoadIdentity(CTX_VOID )
1729{
1730 GET_CONTEXT;
1731 CHECK_CONTEXT;
1732 (*CC->API.LoadIdentity)( CC );
1733}
1734
1735
1736void GLAPIENTRY glLoadMatrixd(CTX_ARG const GLdouble *m )
1737{
1738 GLfloat fm[16];
1739 GLuint i;
1740 GET_CONTEXT;
1741 CHECK_CONTEXT;
1742
1743 for (i=0;i<16;i++) {
1744 fm[i] = (GLfloat) m[i];
1745 }
1746
1747 (*CC->API.LoadMatrixf)( CC, fm );
1748}
1749
1750
1751void GLAPIENTRY glLoadMatrixf(CTX_ARG const GLfloat *m )
1752{
1753 GET_CONTEXT;
1754 CHECK_CONTEXT;
1755 (*CC->API.LoadMatrixf)( CC, m );
1756}
1757
1758
1759void GLAPIENTRY glLoadName(CTX_ARG GLuint name )
1760{
1761 GET_CONTEXT;
1762 CHECK_CONTEXT;
1763 (*CC->API.LoadName)(CC, name);
1764}
1765
1766
1767void GLAPIENTRY glLogicOp(CTX_ARG GLenum opcode )
1768{
1769 GET_CONTEXT;
1770 CHECK_CONTEXT;
1771 (*CC->API.LogicOp)(CC, opcode);
1772}
1773
1774
1775
1776void GLAPIENTRY glMap1d(CTX_ARG GLenum target, GLdouble u1, GLdouble u2, GLint stride,
1777 GLint order, const GLdouble *points )
1778{
1779 GLfloat *pnts;
1780 GLboolean retain;
1781 GET_CONTEXT;
1782 CHECK_CONTEXT;
1783
1784 pnts = gl_copy_map_points1d( target, stride, order, points );
1785 retain = CC->CompileFlag;
1786 (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
1787}
1788
1789
1790void GLAPIENTRY glMap1f(CTX_ARG GLenum target, GLfloat u1, GLfloat u2, GLint stride,
1791 GLint order, const GLfloat *points )
1792{
1793 GLfloat *pnts;
1794 GLboolean retain;
1795 GET_CONTEXT;
1796 CHECK_CONTEXT;
1797
1798 pnts = gl_copy_map_points1f( target, stride, order, points );
1799 retain = CC->CompileFlag;
1800 (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
1801}
1802
1803
1804void GLAPIENTRY glMap2d(CTX_ARG GLenum target,
1805 GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
1806 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
1807 const GLdouble *points )
1808{
1809 GLfloat *pnts;
1810 GLboolean retain;
1811 GET_CONTEXT;
1812 CHECK_CONTEXT;
1813
1814 pnts = gl_copy_map_points2d( target, ustride, uorder,
1815 vstride, vorder, points );
1816 retain = CC->CompileFlag;
1817 (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
1818 v1, v2, vstride, vorder, pnts, retain );
1819}
1820
1821
1822void GLAPIENTRY glMap2f(CTX_ARG GLenum target,
1823 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
1824 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
1825 const GLfloat *points )
1826{
1827 GLfloat *pnts;
1828 GLboolean retain;
1829 GET_CONTEXT;
1830 CHECK_CONTEXT;
1831
1832 pnts = gl_copy_map_points2f( target, ustride, uorder,
1833 vstride, vorder, points );
1834 retain = CC->CompileFlag;
1835 (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
1836 v1, v2, vstride, vorder, pnts, retain );
1837}
1838
1839
1840void GLAPIENTRY glMapGrid1d(CTX_ARG GLint un, GLdouble u1, GLdouble u2 )
1841{
1842 GET_CONTEXT;
1843 CHECK_CONTEXT;
1844 (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
1845}
1846
1847
1848void GLAPIENTRY glMapGrid1f(CTX_ARG GLint un, GLfloat u1, GLfloat u2 )
1849{
1850 GET_CONTEXT;
1851 CHECK_CONTEXT;
1852 (*CC->API.MapGrid1f)( CC, un, u1, u2 );
1853}
1854
1855
1856void GLAPIENTRY glMapGrid2d(CTX_ARG GLint un, GLdouble u1, GLdouble u2,
1857 GLint vn, GLdouble v1, GLdouble v2 )
1858{
1859 GET_CONTEXT;
1860 CHECK_CONTEXT;
1861 (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
1862 vn, (GLfloat) v1, (GLfloat) v2 );
1863}
1864
1865
1866void GLAPIENTRY glMapGrid2f(CTX_ARG GLint un, GLfloat u1, GLfloat u2,
1867 GLint vn, GLfloat v1, GLfloat v2 )
1868{
1869 GET_CONTEXT;
1870 CHECK_CONTEXT;
1871 (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
1872}
1873
1874
1875void GLAPIENTRY glMaterialf(CTX_ARG GLenum face, GLenum pname, GLfloat param )
1876{
1877 GET_CONTEXT;
1878 CHECK_CONTEXT;
1879 gl_Materialfv( CC, face, pname, &param );
1880}
1881
1882
1883
1884void GLAPIENTRY glMateriali(CTX_ARG GLenum face, GLenum pname, GLint param )
1885{
1886 GLfloat fparam[4];
1887 GET_CONTEXT;
1888 CHECK_CONTEXT;
1889 fparam[0] = (GLfloat) param;
1890 gl_Materialfv( CC, face, pname, fparam );
1891}
1892
1893
1894void GLAPIENTRY glMaterialfv(CTX_ARG GLenum face, GLenum pname, const GLfloat *params )
1895{
1896 GET_CONTEXT;
1897 CHECK_CONTEXT;
1898 gl_Materialfv( CC, face, pname, params );
1899}
1900
1901
1902void GLAPIENTRY glMaterialiv(CTX_ARG GLenum face, GLenum pname, const GLint *params )
1903{
1904 GLfloat fparam[4];
1905 GET_CONTEXT;
1906 CHECK_CONTEXT;
1907 switch (pname) {
1908 case GL_AMBIENT:
1909 case GL_DIFFUSE:
1910 case GL_SPECULAR:
1911 case GL_EMISSION:
1912 case GL_AMBIENT_AND_DIFFUSE:
1913 fparam[0] = INT_TO_FLOAT( params[0] );
1914 fparam[1] = INT_TO_FLOAT( params[1] );
1915 fparam[2] = INT_TO_FLOAT( params[2] );
1916 fparam[3] = INT_TO_FLOAT( params[3] );
1917 break;
1918 case GL_SHININESS:
1919 fparam[0] = (GLfloat) params[0];
1920 break;
1921 case GL_COLOR_INDEXES:
1922 fparam[0] = (GLfloat) params[0];
1923 fparam[1] = (GLfloat) params[1];
1924 fparam[2] = (GLfloat) params[2];
1925 break;
1926 default:
1927 /* Error will be caught later in gl_Materialfv */
1928 ;
1929 }
1930 gl_Materialfv( CC, face, pname, fparam );
1931}
1932
1933
1934void GLAPIENTRY glMatrixMode(CTX_ARG GLenum mode )
1935{
1936 GET_CONTEXT;
1937 CHECK_CONTEXT;
1938 (*CC->API.MatrixMode)( CC, mode );
1939}
1940
1941
1942void GLAPIENTRY glMultMatrixd(CTX_ARG const GLdouble *m )
1943{
1944 GLfloat fm[16];
1945 GLuint i;
1946 GET_CONTEXT;
1947 CHECK_CONTEXT;
1948
1949 for (i=0;i<16;i++) {
1950 fm[i] = (GLfloat) m[i];
1951 }
1952
1953 (*CC->API.MultMatrixf)( CC, fm );
1954}
1955
1956
1957void GLAPIENTRY glMultMatrixf(CTX_ARG const GLfloat *m )
1958{
1959 GET_CONTEXT;
1960 CHECK_CONTEXT;
1961 (*CC->API.MultMatrixf)( CC, m );
1962}
1963
1964
1965void GLAPIENTRY glNewList(CTX_ARG GLuint list, GLenum mode )
1966{
1967 GET_CONTEXT;
1968 CHECK_CONTEXT;
1969 (*CC->API.NewList)(CC, list, mode);
1970}
1971
1972
1973/* KW: Now that we build buffers for display lists the same way we
1974 * fill the vb, we can do the work here without a second function
1975 * call. The Flag member allows the identification of missing
1976 * (ie shared) normals.
1977 */
1978#define NORMAL( x,y,z ) \
1979{ \
1980 GLuint count; \
1981 GLfloat *normal; \
1982 GET_IMMEDIATE; \
1983 count = IM->Count; \
1984 IM->Flag[count] |= VERT_NORM; \
1985 normal = IM->Normal[count]; \
1986 ASSIGN_3V(normal, x,y,z); \
1987}
1988
1989
1990void GLAPIENTRY glNormal3b(CTX_ARG GLbyte nx, GLbyte ny, GLbyte nz )
1991{
1992 NORMAL( BYTE_TO_FLOAT(nx),
1993 BYTE_TO_FLOAT(ny),
1994 BYTE_TO_FLOAT(nz) );
1995}
1996
1997
1998void GLAPIENTRY glNormal3d(CTX_ARG GLdouble nx, GLdouble ny, GLdouble nz )
1999{
2000 NORMAL(nx,ny,nz);
2001}
2002
2003
2004void GLAPIENTRY glNormal3f(CTX_ARG GLfloat nx, GLfloat ny, GLfloat nz )
2005{
2006 NORMAL(nx,ny,nz);
2007}
2008
2009
2010void GLAPIENTRY glNormal3i(CTX_ARG GLint nx, GLint ny, GLint nz )
2011{
2012 NORMAL( INT_TO_FLOAT(nx),
2013 INT_TO_FLOAT(ny),
2014 INT_TO_FLOAT(nz) );
2015}
2016
2017
2018void GLAPIENTRY glNormal3s(CTX_ARG GLshort nx, GLshort ny, GLshort nz )
2019{
2020 NORMAL( SHORT_TO_FLOAT(nx),
2021 SHORT_TO_FLOAT(ny),
2022 SHORT_TO_FLOAT(nz) );
2023}
2024
2025
2026void GLAPIENTRY glNormal3bv(CTX_ARG const GLbyte *v )
2027{
2028 NORMAL( BYTE_TO_FLOAT(v[0]),
2029 BYTE_TO_FLOAT(v[1]),
2030 BYTE_TO_FLOAT(v[2]) );
2031}
2032
2033
2034void GLAPIENTRY glNormal3dv(CTX_ARG const GLdouble *v )
2035{
2036 NORMAL( v[0], v[1], v[2] );
2037}
2038
2039
2040void GLAPIENTRY glNormal3fv(CTX_ARG const GLfloat *v )
2041{
2042 NORMAL( v[0], v[1], v[2] );
2043}
2044
2045
2046void GLAPIENTRY glNormal3iv(CTX_ARG const GLint *v )
2047{
2048 NORMAL( INT_TO_FLOAT(v[0]),
2049 INT_TO_FLOAT(v[1]),
2050 INT_TO_FLOAT(v[2]) );
2051}
2052
2053
2054void GLAPIENTRY glNormal3sv(CTX_ARG const GLshort *v )
2055{
2056 NORMAL( SHORT_TO_FLOAT(v[0]),
2057 SHORT_TO_FLOAT(v[1]),
2058 SHORT_TO_FLOAT(v[2]) );
2059}
2060
Note: See TracBrowser for help on using the repository browser.