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

Last change on this file since 2999 was 2938, checked in by sandervl, 25 years ago

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