projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
generate INVALID_OPERATION if active texture != 0 in glMap[12][fd]
[mesa.git] / src / mesa / main / eval.c
1 /* $Id: eval.c,v 1.20 2001/05/16 17:06:28 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.5
6 *
7 * Copyright (C) 1999-2001 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 * eval.c was written by
30 * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
31 * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
32 *
33 * My original implementation of evaluators was simplistic and didn't
34 * compute surface normal vectors properly. Bernd and Volker applied
35 * used more sophisticated methods to get better results.
36 *
37 * Thanks guys!
38 */
39
40
41 #ifdef PC_HEADER
42 #include "all.h"
43 #else
44 #include "glheader.h"
45 #include "colormac.h"
46 #include "context.h"
47 #include "eval.h"
48 #include "macros.h"
49 #include "mem.h"
50 #include "mmath.h"
51 #include "mtypes.h"
52 #endif
53
54
55 /*
56 * Return the number of components per control point for any type of
57 * evaluator. Return 0 if bad target.
58 * See table 5.1 in the OpenGL 1.2 spec.
59 */
60 GLuint _mesa_evaluator_components( GLenum target )
61 {
62 switch (target) {
63 case GL_MAP1_VERTEX_3: return 3;
64 case GL_MAP1_VERTEX_4: return 4;
65 case GL_MAP1_INDEX: return 1;
66 case GL_MAP1_COLOR_4: return 4;
67 case GL_MAP1_NORMAL: return 3;
68 case GL_MAP1_TEXTURE_COORD_1: return 1;
69 case GL_MAP1_TEXTURE_COORD_2: return 2;
70 case GL_MAP1_TEXTURE_COORD_3: return 3;
71 case GL_MAP1_TEXTURE_COORD_4: return 4;
72 case GL_MAP2_VERTEX_3: return 3;
73 case GL_MAP2_VERTEX_4: return 4;
74 case GL_MAP2_INDEX: return 1;
75 case GL_MAP2_COLOR_4: return 4;
76 case GL_MAP2_NORMAL: return 3;
77 case GL_MAP2_TEXTURE_COORD_1: return 1;
78 case GL_MAP2_TEXTURE_COORD_2: return 2;
79 case GL_MAP2_TEXTURE_COORD_3: return 3;
80 case GL_MAP2_TEXTURE_COORD_4: return 4;
81 default: return 0;
82 }
83 }
84
85
86 /**********************************************************************/
87 /*** Copy and deallocate control points ***/
88 /**********************************************************************/
89
90
91 /*
92 * Copy 1-parametric evaluator control points from user-specified
93 * memory space to a buffer of contiguous control points.
94 * Input: see glMap1f for details
95 * Return: pointer to buffer of contiguous control points or NULL if out
96 * of memory.
97 */
98 GLfloat *_mesa_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
99 const GLfloat *points )
100 {
101 GLfloat *buffer, *p;
102 GLint i, k, size = _mesa_evaluator_components(target);
103
104 if (!points || size==0) {
105 return NULL;
106 }
107
108 buffer = (GLfloat *) MALLOC(uorder * size * sizeof(GLfloat));
109
110 if(buffer)
111 for(i=0, p=buffer; i<uorder; i++, points+=ustride)
112 for(k=0; k<size; k++)
113 *p++ = points[k];
114
115 return buffer;
116 }
117
118
119
120 /*
121 * Same as above but convert doubles to floats.
122 */
123 GLfloat *_mesa_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
124 const GLdouble *points )
125 {
126 GLfloat *buffer, *p;
127 GLint i, k, size = _mesa_evaluator_components(target);
128
129 if (!points || size==0) {
130 return NULL;
131 }
132
133 buffer = (GLfloat *) MALLOC(uorder * size * sizeof(GLfloat));
134
135 if(buffer)
136 for(i=0, p=buffer; i<uorder; i++, points+=ustride)
137 for(k=0; k<size; k++)
138 *p++ = (GLfloat) points[k];
139
140 return buffer;
141 }
142
143
144
145 /*
146 * Copy 2-parametric evaluator control points from user-specified
147 * memory space to a buffer of contiguous control points.
148 * Additional memory is allocated to be used by the horner and
149 * de Casteljau evaluation schemes.
150 *
151 * Input: see glMap2f for details
152 * Return: pointer to buffer of contiguous control points or NULL if out
153 * of memory.
154 */
155 GLfloat *_mesa_copy_map_points2f( GLenum target,
156 GLint ustride, GLint uorder,
157 GLint vstride, GLint vorder,
158 const GLfloat *points )
159 {
160 GLfloat *buffer, *p;
161 GLint i, j, k, size, dsize, hsize;
162 GLint uinc;
163
164 size = _mesa_evaluator_components(target);
165
166 if (!points || size==0) {
167 return NULL;
168 }
169
170 /* max(uorder, vorder) additional points are used in */
171 /* horner evaluation and uorder*vorder additional */
172 /* values are needed for de Casteljau */
173 dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
174 hsize = (uorder > vorder ? uorder : vorder)*size;
175
176 if(hsize>dsize)
177 buffer = (GLfloat *) MALLOC((uorder*vorder*size+hsize)*sizeof(GLfloat));
178 else
179 buffer = (GLfloat *) MALLOC((uorder*vorder*size+dsize)*sizeof(GLfloat));
180
181 /* compute the increment value for the u-loop */
182 uinc = ustride - vorder*vstride;
183
184 if (buffer)
185 for (i=0, p=buffer; i<uorder; i++, points += uinc)
186 for (j=0; j<vorder; j++, points += vstride)
187 for (k=0; k<size; k++)
188 *p++ = points[k];
189
190 return buffer;
191 }
192
193
194
195 /*
196 * Same as above but convert doubles to floats.
197 */
198 GLfloat *_mesa_copy_map_points2d(GLenum target,
199 GLint ustride, GLint uorder,
200 GLint vstride, GLint vorder,
201 const GLdouble *points )
202 {
203 GLfloat *buffer, *p;
204 GLint i, j, k, size, hsize, dsize;
205 GLint uinc;
206
207 size = _mesa_evaluator_components(target);
208
209 if (!points || size==0) {
210 return NULL;
211 }
212
213 /* max(uorder, vorder) additional points are used in */
214 /* horner evaluation and uorder*vorder additional */
215 /* values are needed for de Casteljau */
216 dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
217 hsize = (uorder > vorder ? uorder : vorder)*size;
218
219 if(hsize>dsize)
220 buffer = (GLfloat *) MALLOC((uorder*vorder*size+hsize)*sizeof(GLfloat));
221 else
222 buffer = (GLfloat *) MALLOC((uorder*vorder*size+dsize)*sizeof(GLfloat));
223
224 /* compute the increment value for the u-loop */
225 uinc = ustride - vorder*vstride;
226
227 if (buffer)
228 for (i=0, p=buffer; i<uorder; i++, points += uinc)
229 for (j=0; j<vorder; j++, points += vstride)
230 for (k=0; k<size; k++)
231 *p++ = (GLfloat) points[k];
232
233 return buffer;
234 }
235
236
237
238
239 /**********************************************************************/
240 /*** API entry points ***/
241 /**********************************************************************/
242
243
244 /*
245 * This does the work of glMap1[fd].
246 */
247 static void
248 map1(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
249 GLint uorder, const GLvoid *points, GLenum type )
250 {
251 GET_CURRENT_CONTEXT(ctx);
252 GLint k;
253 GLfloat *pnts;
254 struct gl_1d_map *map = 0;
255 ASSERT_OUTSIDE_BEGIN_END(ctx);
256
257 assert(type == GL_FLOAT || type == GL_DOUBLE);
258
259 if (u1 == u2) {
260 _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
261 return;
262 }
263 if (uorder < 1 || uorder > MAX_EVAL_ORDER) {
264 _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
265 return;
266 }
267 if (!points) {
268 _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(points)" );
269 return;
270 }
271
272 k = _mesa_evaluator_components( target );
273 if (k == 0) {
274 _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
275 }
276
277 if (ustride < k) {
278 _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
279 return;
280 }
281
282 if (ctx->Texture.CurrentUnit != 0) {
283 /* See OpenGL 1.2.1 spec, section F.2.13 */
284 _mesa_error( ctx, GL_INVALID_OPERATION, "glMap2(ACTIVE_TEXTURE != 0)" );
285 return;
286 }
287
288 switch (target) {
289 case GL_MAP1_VERTEX_3:
290 map = &ctx->EvalMap.Map1Vertex3;
291 break;
292 case GL_MAP1_VERTEX_4:
293 map = &ctx->EvalMap.Map1Vertex4;
294 break;
295 case GL_MAP1_INDEX:
296 map = &ctx->EvalMap.Map1Index;
297 break;
298 case GL_MAP1_COLOR_4:
299 map = &ctx->EvalMap.Map1Color4;
300 break;
301 case GL_MAP1_NORMAL:
302 map = &ctx->EvalMap.Map1Normal;
303 break;
304 case GL_MAP1_TEXTURE_COORD_1:
305 map = &ctx->EvalMap.Map1Texture1;
306 break;
307 case GL_MAP1_TEXTURE_COORD_2:
308 map = &ctx->EvalMap.Map1Texture2;
309 break;
310 case GL_MAP1_TEXTURE_COORD_3:
311 map = &ctx->EvalMap.Map1Texture3;
312 break;
313 case GL_MAP1_TEXTURE_COORD_4:
314 map = &ctx->EvalMap.Map1Texture4;
315 break;
316 default:
317 _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
318 return;
319 }
320
321 /* make copy of the control points */
322 if (type == GL_FLOAT)
323 pnts = _mesa_copy_map_points1f(target, ustride, uorder, (GLfloat*) points);
324 else
325 pnts = _mesa_copy_map_points1d(target, ustride, uorder, (GLdouble*) points);
326
327
328 FLUSH_VERTICES(ctx, _NEW_EVAL);
329 map->Order = uorder;
330 map->u1 = u1;
331 map->u2 = u2;
332 map->du = 1.0 / (u2 - u1);
333 if (map->Points)
334 FREE( map->Points );
335 map->Points = pnts;
336 }
337
338
339
340 void
341 _mesa_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
342 GLint order, const GLfloat *points )
343 {
344 map1(target, u1, u2, stride, order, points, GL_FLOAT);
345 }
346
347
348 void
349 _mesa_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
350 GLint order, const GLdouble *points )
351 {
352 map1(target, u1, u2, stride, order, points, GL_DOUBLE);
353 }
354
355
356 static void
357 map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
358 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
359 const GLvoid *points, GLenum type )
360 {
361 GET_CURRENT_CONTEXT(ctx);
362 GLint k;
363 GLfloat *pnts;
364 struct gl_2d_map *map = 0;
365 ASSERT_OUTSIDE_BEGIN_END(ctx);
366
367 if (u1==u2) {
368 _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
369 return;
370 }
371
372 if (v1==v2) {
373 _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
374 return;
375 }
376
377 if (uorder<1 || uorder>MAX_EVAL_ORDER) {
378 _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
379 return;
380 }
381
382 if (vorder<1 || vorder>MAX_EVAL_ORDER) {
383 _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
384 return;
385 }
386
387 k = _mesa_evaluator_components( target );
388 if (k==0) {
389 _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
390 }
391
392 if (ustride < k) {
393 _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
394 return;
395 }
396 if (vstride < k) {
397 _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
398 return;
399 }
400
401 if (ctx->Texture.CurrentUnit != 0) {
402 /* See OpenGL 1.2.1 spec, section F.2.13 */
403 _mesa_error( ctx, GL_INVALID_OPERATION, "glMap2(ACTIVE_TEXTURE != 0)" );
404 return;
405 }
406
407 switch (target) {
408 case GL_MAP2_VERTEX_3:
409 map = &ctx->EvalMap.Map2Vertex3;
410 break;
411 case GL_MAP2_VERTEX_4:
412 map = &ctx->EvalMap.Map2Vertex4;
413 break;
414 case GL_MAP2_INDEX:
415 map = &ctx->EvalMap.Map2Index;
416 break;
417 case GL_MAP2_COLOR_4:
418 map = &ctx->EvalMap.Map2Color4;
419 break;
420 case GL_MAP2_NORMAL:
421 map = &ctx->EvalMap.Map2Normal;
422 break;
423 case GL_MAP2_TEXTURE_COORD_1:
424 map = &ctx->EvalMap.Map2Texture1;
425 break;
426 case GL_MAP2_TEXTURE_COORD_2:
427 map = &ctx->EvalMap.Map2Texture2;
428 break;
429 case GL_MAP2_TEXTURE_COORD_3:
430 map = &ctx->EvalMap.Map2Texture3;
431 break;
432 case GL_MAP2_TEXTURE_COORD_4:
433 map = &ctx->EvalMap.Map2Texture4;
434 break;
435 default:
436 _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
437 return;
438 }
439
440 /* make copy of the control points */
441 if (type == GL_FLOAT)
442 pnts = _mesa_copy_map_points2f(target, ustride, uorder,
443 vstride, vorder, (GLfloat*) points);
444 else
445 pnts = _mesa_copy_map_points2d(target, ustride, uorder,
446 vstride, vorder, (GLdouble*) points);
447
448
449 FLUSH_VERTICES(ctx, _NEW_EVAL);
450 map->Uorder = uorder;
451 map->u1 = u1;
452 map->u2 = u2;
453 map->du = 1.0 / (u2 - u1);
454 map->Vorder = vorder;
455 map->v1 = v1;
456 map->v2 = v2;
457 map->dv = 1.0 / (v2 - v1);
458 if (map->Points)
459 FREE( map->Points );
460 map->Points = pnts;
461 }
462
463
464 void
465 _mesa_Map2f( GLenum target,
466 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
467 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
468 const GLfloat *points)
469 {
470 map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
471 points, GL_FLOAT);
472 }
473
474
475 void
476 _mesa_Map2d( GLenum target,
477 GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
478 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
479 const GLdouble *points )
480 {
481 map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
482 points, GL_DOUBLE);
483 }
484
485
486
487 void
488 _mesa_GetMapdv( GLenum target, GLenum query, GLdouble *v )
489 {
490 GET_CURRENT_CONTEXT(ctx);
491 GLint i, n;
492 GLfloat *data;
493 ASSERT_OUTSIDE_BEGIN_END(ctx);
494
495 switch (query) {
496 case GL_COEFF:
497 switch (target) {
498 case GL_MAP1_COLOR_4:
499 data = ctx->EvalMap.Map1Color4.Points;
500 n = ctx->EvalMap.Map1Color4.Order * 4;
501 break;
502 case GL_MAP1_INDEX:
503 data = ctx->EvalMap.Map1Index.Points;
504 n = ctx->EvalMap.Map1Index.Order;
505 break;
506 case GL_MAP1_NORMAL:
507 data = ctx->EvalMap.Map1Normal.Points;
508 n = ctx->EvalMap.Map1Normal.Order * 3;
509 break;
510 case GL_MAP1_TEXTURE_COORD_1:
511 data = ctx->EvalMap.Map1Texture1.Points;
512 n = ctx->EvalMap.Map1Texture1.Order * 1;
513 break;
514 case GL_MAP1_TEXTURE_COORD_2:
515 data = ctx->EvalMap.Map1Texture2.Points;
516 n = ctx->EvalMap.Map1Texture2.Order * 2;
517 break;
518 case GL_MAP1_TEXTURE_COORD_3:
519 data = ctx->EvalMap.Map1Texture3.Points;
520 n = ctx->EvalMap.Map1Texture3.Order * 3;
521 break;
522 case GL_MAP1_TEXTURE_COORD_4:
523 data = ctx->EvalMap.Map1Texture4.Points;
524 n = ctx->EvalMap.Map1Texture4.Order * 4;
525 break;
526 case GL_MAP1_VERTEX_3:
527 data = ctx->EvalMap.Map1Vertex3.Points;
528 n = ctx->EvalMap.Map1Vertex3.Order * 3;
529 break;
530 case GL_MAP1_VERTEX_4:
531 data = ctx->EvalMap.Map1Vertex4.Points;
532 n = ctx->EvalMap.Map1Vertex4.Order * 4;
533 break;
534 case GL_MAP2_COLOR_4:
535 data = ctx->EvalMap.Map2Color4.Points;
536 n = ctx->EvalMap.Map2Color4.Uorder
537 * ctx->EvalMap.Map2Color4.Vorder * 4;
538 break;
539 case GL_MAP2_INDEX:
540 data = ctx->EvalMap.Map2Index.Points;
541 n = ctx->EvalMap.Map2Index.Uorder
542 * ctx->EvalMap.Map2Index.Vorder;
543 break;
544 case GL_MAP2_NORMAL:
545 data = ctx->EvalMap.Map2Normal.Points;
546 n = ctx->EvalMap.Map2Normal.Uorder
547 * ctx->EvalMap.Map2Normal.Vorder * 3;
548 break;
549 case GL_MAP2_TEXTURE_COORD_1:
550 data = ctx->EvalMap.Map2Texture1.Points;
551 n = ctx->EvalMap.Map2Texture1.Uorder
552 * ctx->EvalMap.Map2Texture1.Vorder * 1;
553 break;
554 case GL_MAP2_TEXTURE_COORD_2:
555 data = ctx->EvalMap.Map2Texture2.Points;
556 n = ctx->EvalMap.Map2Texture2.Uorder
557 * ctx->EvalMap.Map2Texture2.Vorder * 2;
558 break;
559 case GL_MAP2_TEXTURE_COORD_3:
560 data = ctx->EvalMap.Map2Texture3.Points;
561 n = ctx->EvalMap.Map2Texture3.Uorder
562 * ctx->EvalMap.Map2Texture3.Vorder * 3;
563 break;
564 case GL_MAP2_TEXTURE_COORD_4:
565 data = ctx->EvalMap.Map2Texture4.Points;
566 n = ctx->EvalMap.Map2Texture4.Uorder
567 * ctx->EvalMap.Map2Texture4.Vorder * 4;
568 break;
569 case GL_MAP2_VERTEX_3:
570 data = ctx->EvalMap.Map2Vertex3.Points;
571 n = ctx->EvalMap.Map2Vertex3.Uorder
572 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
573 break;
574 case GL_MAP2_VERTEX_4:
575 data = ctx->EvalMap.Map2Vertex4.Points;
576 n = ctx->EvalMap.Map2Vertex4.Uorder
577 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
578 break;
579 default:
580 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
581 return;
582 }
583 if (data) {
584 for (i=0;i<n;i++) {
585 v[i] = data[i];
586 }
587 }
588 break;
589 case GL_ORDER:
590 switch (target) {
591 case GL_MAP1_COLOR_4:
592 *v = ctx->EvalMap.Map1Color4.Order;
593 break;
594 case GL_MAP1_INDEX:
595 *v = ctx->EvalMap.Map1Index.Order;
596 break;
597 case GL_MAP1_NORMAL:
598 *v = ctx->EvalMap.Map1Normal.Order;
599 break;
600 case GL_MAP1_TEXTURE_COORD_1:
601 *v = ctx->EvalMap.Map1Texture1.Order;
602 break;
603 case GL_MAP1_TEXTURE_COORD_2:
604 *v = ctx->EvalMap.Map1Texture2.Order;
605 break;
606 case GL_MAP1_TEXTURE_COORD_3:
607 *v = ctx->EvalMap.Map1Texture3.Order;
608 break;
609 case GL_MAP1_TEXTURE_COORD_4:
610 *v = ctx->EvalMap.Map1Texture4.Order;
611 break;
612 case GL_MAP1_VERTEX_3:
613 *v = ctx->EvalMap.Map1Vertex3.Order;
614 break;
615 case GL_MAP1_VERTEX_4:
616 *v = ctx->EvalMap.Map1Vertex4.Order;
617 break;
618 case GL_MAP2_COLOR_4:
619 v[0] = ctx->EvalMap.Map2Color4.Uorder;
620 v[1] = ctx->EvalMap.Map2Color4.Vorder;
621 break;
622 case GL_MAP2_INDEX:
623 v[0] = ctx->EvalMap.Map2Index.Uorder;
624 v[1] = ctx->EvalMap.Map2Index.Vorder;
625 break;
626 case GL_MAP2_NORMAL:
627 v[0] = ctx->EvalMap.Map2Normal.Uorder;
628 v[1] = ctx->EvalMap.Map2Normal.Vorder;
629 break;
630 case GL_MAP2_TEXTURE_COORD_1:
631 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
632 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
633 break;
634 case GL_MAP2_TEXTURE_COORD_2:
635 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
636 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
637 break;
638 case GL_MAP2_TEXTURE_COORD_3:
639 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
640 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
641 break;
642 case GL_MAP2_TEXTURE_COORD_4:
643 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
644 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
645 break;
646 case GL_MAP2_VERTEX_3:
647 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
648 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
649 break;
650 case GL_MAP2_VERTEX_4:
651 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
652 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
653 break;
654 default:
655 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
656 return;
657 }
658 break;
659 case GL_DOMAIN:
660 switch (target) {
661 case GL_MAP1_COLOR_4:
662 v[0] = ctx->EvalMap.Map1Color4.u1;
663 v[1] = ctx->EvalMap.Map1Color4.u2;
664 break;
665 case GL_MAP1_INDEX:
666 v[0] = ctx->EvalMap.Map1Index.u1;
667 v[1] = ctx->EvalMap.Map1Index.u2;
668 break;
669 case GL_MAP1_NORMAL:
670 v[0] = ctx->EvalMap.Map1Normal.u1;
671 v[1] = ctx->EvalMap.Map1Normal.u2;
672 break;
673 case GL_MAP1_TEXTURE_COORD_1:
674 v[0] = ctx->EvalMap.Map1Texture1.u1;
675 v[1] = ctx->EvalMap.Map1Texture1.u2;
676 break;
677 case GL_MAP1_TEXTURE_COORD_2:
678 v[0] = ctx->EvalMap.Map1Texture2.u1;
679 v[1] = ctx->EvalMap.Map1Texture2.u2;
680 break;
681 case GL_MAP1_TEXTURE_COORD_3:
682 v[0] = ctx->EvalMap.Map1Texture3.u1;
683 v[1] = ctx->EvalMap.Map1Texture3.u2;
684 break;
685 case GL_MAP1_TEXTURE_COORD_4:
686 v[0] = ctx->EvalMap.Map1Texture4.u1;
687 v[1] = ctx->EvalMap.Map1Texture4.u2;
688 break;
689 case GL_MAP1_VERTEX_3:
690 v[0] = ctx->EvalMap.Map1Vertex3.u1;
691 v[1] = ctx->EvalMap.Map1Vertex3.u2;
692 break;
693 case GL_MAP1_VERTEX_4:
694 v[0] = ctx->EvalMap.Map1Vertex4.u1;
695 v[1] = ctx->EvalMap.Map1Vertex4.u2;
696 break;
697 case GL_MAP2_COLOR_4:
698 v[0] = ctx->EvalMap.Map2Color4.u1;
699 v[1] = ctx->EvalMap.Map2Color4.u2;
700 v[2] = ctx->EvalMap.Map2Color4.v1;
701 v[3] = ctx->EvalMap.Map2Color4.v2;
702 break;
703 case GL_MAP2_INDEX:
704 v[0] = ctx->EvalMap.Map2Index.u1;
705 v[1] = ctx->EvalMap.Map2Index.u2;
706 v[2] = ctx->EvalMap.Map2Index.v1;
707 v[3] = ctx->EvalMap.Map2Index.v2;
708 break;
709 case GL_MAP2_NORMAL:
710 v[0] = ctx->EvalMap.Map2Normal.u1;
711 v[1] = ctx->EvalMap.Map2Normal.u2;
712 v[2] = ctx->EvalMap.Map2Normal.v1;
713 v[3] = ctx->EvalMap.Map2Normal.v2;
714 break;
715 case GL_MAP2_TEXTURE_COORD_1:
716 v[0] = ctx->EvalMap.Map2Texture1.u1;
717 v[1] = ctx->EvalMap.Map2Texture1.u2;
718 v[2] = ctx->EvalMap.Map2Texture1.v1;
719 v[3] = ctx->EvalMap.Map2Texture1.v2;
720 break;
721 case GL_MAP2_TEXTURE_COORD_2:
722 v[0] = ctx->EvalMap.Map2Texture2.u1;
723 v[1] = ctx->EvalMap.Map2Texture2.u2;
724 v[2] = ctx->EvalMap.Map2Texture2.v1;
725 v[3] = ctx->EvalMap.Map2Texture2.v2;
726 break;
727 case GL_MAP2_TEXTURE_COORD_3:
728 v[0] = ctx->EvalMap.Map2Texture3.u1;
729 v[1] = ctx->EvalMap.Map2Texture3.u2;
730 v[2] = ctx->EvalMap.Map2Texture3.v1;
731 v[3] = ctx->EvalMap.Map2Texture3.v2;
732 break;
733 case GL_MAP2_TEXTURE_COORD_4:
734 v[0] = ctx->EvalMap.Map2Texture4.u1;
735 v[1] = ctx->EvalMap.Map2Texture4.u2;
736 v[2] = ctx->EvalMap.Map2Texture4.v1;
737 v[3] = ctx->EvalMap.Map2Texture4.v2;
738 break;
739 case GL_MAP2_VERTEX_3:
740 v[0] = ctx->EvalMap.Map2Vertex3.u1;
741 v[1] = ctx->EvalMap.Map2Vertex3.u2;
742 v[2] = ctx->EvalMap.Map2Vertex3.v1;
743 v[3] = ctx->EvalMap.Map2Vertex3.v2;
744 break;
745 case GL_MAP2_VERTEX_4:
746 v[0] = ctx->EvalMap.Map2Vertex4.u1;
747 v[1] = ctx->EvalMap.Map2Vertex4.u2;
748 v[2] = ctx->EvalMap.Map2Vertex4.v1;
749 v[3] = ctx->EvalMap.Map2Vertex4.v2;
750 break;
751 default:
752 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
753 }
754 break;
755 default:
756 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
757 }
758 }
759
760
761 void
762 _mesa_GetMapfv( GLenum target, GLenum query, GLfloat *v )
763 {
764 GET_CURRENT_CONTEXT(ctx);
765 GLint i, n;
766 GLfloat *data;
767 ASSERT_OUTSIDE_BEGIN_END(ctx);
768
769 switch (query) {
770 case GL_COEFF:
771 switch (target) {
772 case GL_MAP1_COLOR_4:
773 data = ctx->EvalMap.Map1Color4.Points;
774 n = ctx->EvalMap.Map1Color4.Order * 4;
775 break;
776 case GL_MAP1_INDEX:
777 data = ctx->EvalMap.Map1Index.Points;
778 n = ctx->EvalMap.Map1Index.Order;
779 break;
780 case GL_MAP1_NORMAL:
781 data = ctx->EvalMap.Map1Normal.Points;
782 n = ctx->EvalMap.Map1Normal.Order * 3;
783 break;
784 case GL_MAP1_TEXTURE_COORD_1:
785 data = ctx->EvalMap.Map1Texture1.Points;
786 n = ctx->EvalMap.Map1Texture1.Order * 1;
787 break;
788 case GL_MAP1_TEXTURE_COORD_2:
789 data = ctx->EvalMap.Map1Texture2.Points;
790 n = ctx->EvalMap.Map1Texture2.Order * 2;
791 break;
792 case GL_MAP1_TEXTURE_COORD_3:
793 data = ctx->EvalMap.Map1Texture3.Points;
794 n = ctx->EvalMap.Map1Texture3.Order * 3;
795 break;
796 case GL_MAP1_TEXTURE_COORD_4:
797 data = ctx->EvalMap.Map1Texture4.Points;
798 n = ctx->EvalMap.Map1Texture4.Order * 4;
799 break;
800 case GL_MAP1_VERTEX_3:
801 data = ctx->EvalMap.Map1Vertex3.Points;
802 n = ctx->EvalMap.Map1Vertex3.Order * 3;
803 break;
804 case GL_MAP1_VERTEX_4:
805 data = ctx->EvalMap.Map1Vertex4.Points;
806 n = ctx->EvalMap.Map1Vertex4.Order * 4;
807 break;
808 case GL_MAP2_COLOR_4:
809 data = ctx->EvalMap.Map2Color4.Points;
810 n = ctx->EvalMap.Map2Color4.Uorder
811 * ctx->EvalMap.Map2Color4.Vorder * 4;
812 break;
813 case GL_MAP2_INDEX:
814 data = ctx->EvalMap.Map2Index.Points;
815 n = ctx->EvalMap.Map2Index.Uorder
816 * ctx->EvalMap.Map2Index.Vorder;
817 break;
818 case GL_MAP2_NORMAL:
819 data = ctx->EvalMap.Map2Normal.Points;
820 n = ctx->EvalMap.Map2Normal.Uorder
821 * ctx->EvalMap.Map2Normal.Vorder * 3;
822 break;
823 case GL_MAP2_TEXTURE_COORD_1:
824 data = ctx->EvalMap.Map2Texture1.Points;
825 n = ctx->EvalMap.Map2Texture1.Uorder
826 * ctx->EvalMap.Map2Texture1.Vorder * 1;
827 break;
828 case GL_MAP2_TEXTURE_COORD_2:
829 data = ctx->EvalMap.Map2Texture2.Points;
830 n = ctx->EvalMap.Map2Texture2.Uorder
831 * ctx->EvalMap.Map2Texture2.Vorder * 2;
832 break;
833 case GL_MAP2_TEXTURE_COORD_3:
834 data = ctx->EvalMap.Map2Texture3.Points;
835 n = ctx->EvalMap.Map2Texture3.Uorder
836 * ctx->EvalMap.Map2Texture3.Vorder * 3;
837 break;
838 case GL_MAP2_TEXTURE_COORD_4:
839 data = ctx->EvalMap.Map2Texture4.Points;
840 n = ctx->EvalMap.Map2Texture4.Uorder
841 * ctx->EvalMap.Map2Texture4.Vorder * 4;
842 break;
843 case GL_MAP2_VERTEX_3:
844 data = ctx->EvalMap.Map2Vertex3.Points;
845 n = ctx->EvalMap.Map2Vertex3.Uorder
846 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
847 break;
848 case GL_MAP2_VERTEX_4:
849 data = ctx->EvalMap.Map2Vertex4.Points;
850 n = ctx->EvalMap.Map2Vertex4.Uorder
851 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
852 break;
853 default:
854 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
855 return;
856 }
857 if (data) {
858 for (i=0;i<n;i++) {
859 v[i] = data[i];
860 }
861 }
862 break;
863 case GL_ORDER:
864 switch (target) {
865 case GL_MAP1_COLOR_4:
866 *v = ctx->EvalMap.Map1Color4.Order;
867 break;
868 case GL_MAP1_INDEX:
869 *v = ctx->EvalMap.Map1Index.Order;
870 break;
871 case GL_MAP1_NORMAL:
872 *v = ctx->EvalMap.Map1Normal.Order;
873 break;
874 case GL_MAP1_TEXTURE_COORD_1:
875 *v = ctx->EvalMap.Map1Texture1.Order;
876 break;
877 case GL_MAP1_TEXTURE_COORD_2:
878 *v = ctx->EvalMap.Map1Texture2.Order;
879 break;
880 case GL_MAP1_TEXTURE_COORD_3:
881 *v = ctx->EvalMap.Map1Texture3.Order;
882 break;
883 case GL_MAP1_TEXTURE_COORD_4:
884 *v = ctx->EvalMap.Map1Texture4.Order;
885 break;
886 case GL_MAP1_VERTEX_3:
887 *v = ctx->EvalMap.Map1Vertex3.Order;
888 break;
889 case GL_MAP1_VERTEX_4:
890 *v = ctx->EvalMap.Map1Vertex4.Order;
891 break;
892 case GL_MAP2_COLOR_4:
893 v[0] = ctx->EvalMap.Map2Color4.Uorder;
894 v[1] = ctx->EvalMap.Map2Color4.Vorder;
895 break;
896 case GL_MAP2_INDEX:
897 v[0] = ctx->EvalMap.Map2Index.Uorder;
898 v[1] = ctx->EvalMap.Map2Index.Vorder;
899 break;
900 case GL_MAP2_NORMAL:
901 v[0] = ctx->EvalMap.Map2Normal.Uorder;
902 v[1] = ctx->EvalMap.Map2Normal.Vorder;
903 break;
904 case GL_MAP2_TEXTURE_COORD_1:
905 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
906 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
907 break;
908 case GL_MAP2_TEXTURE_COORD_2:
909 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
910 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
911 break;
912 case GL_MAP2_TEXTURE_COORD_3:
913 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
914 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
915 break;
916 case GL_MAP2_TEXTURE_COORD_4:
917 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
918 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
919 break;
920 case GL_MAP2_VERTEX_3:
921 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
922 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
923 break;
924 case GL_MAP2_VERTEX_4:
925 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
926 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
927 break;
928 default:
929 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
930 return;
931 }
932 break;
933 case GL_DOMAIN:
934 switch (target) {
935 case GL_MAP1_COLOR_4:
936 v[0] = ctx->EvalMap.Map1Color4.u1;
937 v[1] = ctx->EvalMap.Map1Color4.u2;
938 break;
939 case GL_MAP1_INDEX:
940 v[0] = ctx->EvalMap.Map1Index.u1;
941 v[1] = ctx->EvalMap.Map1Index.u2;
942 break;
943 case GL_MAP1_NORMAL:
944 v[0] = ctx->EvalMap.Map1Normal.u1;
945 v[1] = ctx->EvalMap.Map1Normal.u2;
946 break;
947 case GL_MAP1_TEXTURE_COORD_1:
948 v[0] = ctx->EvalMap.Map1Texture1.u1;
949 v[1] = ctx->EvalMap.Map1Texture1.u2;
950 break;
951 case GL_MAP1_TEXTURE_COORD_2:
952 v[0] = ctx->EvalMap.Map1Texture2.u1;
953 v[1] = ctx->EvalMap.Map1Texture2.u2;
954 break;
955 case GL_MAP1_TEXTURE_COORD_3:
956 v[0] = ctx->EvalMap.Map1Texture3.u1;
957 v[1] = ctx->EvalMap.Map1Texture3.u2;
958 break;
959 case GL_MAP1_TEXTURE_COORD_4:
960 v[0] = ctx->EvalMap.Map1Texture4.u1;
961 v[1] = ctx->EvalMap.Map1Texture4.u2;
962 break;
963 case GL_MAP1_VERTEX_3:
964 v[0] = ctx->EvalMap.Map1Vertex3.u1;
965 v[1] = ctx->EvalMap.Map1Vertex3.u2;
966 break;
967 case GL_MAP1_VERTEX_4:
968 v[0] = ctx->EvalMap.Map1Vertex4.u1;
969 v[1] = ctx->EvalMap.Map1Vertex4.u2;
970 break;
971 case GL_MAP2_COLOR_4:
972 v[0] = ctx->EvalMap.Map2Color4.u1;
973 v[1] = ctx->EvalMap.Map2Color4.u2;
974 v[2] = ctx->EvalMap.Map2Color4.v1;
975 v[3] = ctx->EvalMap.Map2Color4.v2;
976 break;
977 case GL_MAP2_INDEX:
978 v[0] = ctx->EvalMap.Map2Index.u1;
979 v[1] = ctx->EvalMap.Map2Index.u2;
980 v[2] = ctx->EvalMap.Map2Index.v1;
981 v[3] = ctx->EvalMap.Map2Index.v2;
982 break;
983 case GL_MAP2_NORMAL:
984 v[0] = ctx->EvalMap.Map2Normal.u1;
985 v[1] = ctx->EvalMap.Map2Normal.u2;
986 v[2] = ctx->EvalMap.Map2Normal.v1;
987 v[3] = ctx->EvalMap.Map2Normal.v2;
988 break;
989 case GL_MAP2_TEXTURE_COORD_1:
990 v[0] = ctx->EvalMap.Map2Texture1.u1;
991 v[1] = ctx->EvalMap.Map2Texture1.u2;
992 v[2] = ctx->EvalMap.Map2Texture1.v1;
993 v[3] = ctx->EvalMap.Map2Texture1.v2;
994 break;
995 case GL_MAP2_TEXTURE_COORD_2:
996 v[0] = ctx->EvalMap.Map2Texture2.u1;
997 v[1] = ctx->EvalMap.Map2Texture2.u2;
998 v[2] = ctx->EvalMap.Map2Texture2.v1;
999 v[3] = ctx->EvalMap.Map2Texture2.v2;
1000 break;
1001 case GL_MAP2_TEXTURE_COORD_3:
1002 v[0] = ctx->EvalMap.Map2Texture3.u1;
1003 v[1] = ctx->EvalMap.Map2Texture3.u2;
1004 v[2] = ctx->EvalMap.Map2Texture3.v1;
1005 v[3] = ctx->EvalMap.Map2Texture3.v2;
1006 break;
1007 case GL_MAP2_TEXTURE_COORD_4:
1008 v[0] = ctx->EvalMap.Map2Texture4.u1;
1009 v[1] = ctx->EvalMap.Map2Texture4.u2;
1010 v[2] = ctx->EvalMap.Map2Texture4.v1;
1011 v[3] = ctx->EvalMap.Map2Texture4.v2;
1012 break;
1013 case GL_MAP2_VERTEX_3:
1014 v[0] = ctx->EvalMap.Map2Vertex3.u1;
1015 v[1] = ctx->EvalMap.Map2Vertex3.u2;
1016 v[2] = ctx->EvalMap.Map2Vertex3.v1;
1017 v[3] = ctx->EvalMap.Map2Vertex3.v2;
1018 break;
1019 case GL_MAP2_VERTEX_4:
1020 v[0] = ctx->EvalMap.Map2Vertex4.u1;
1021 v[1] = ctx->EvalMap.Map2Vertex4.u2;
1022 v[2] = ctx->EvalMap.Map2Vertex4.v1;
1023 v[3] = ctx->EvalMap.Map2Vertex4.v2;
1024 break;
1025 default:
1026 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1027 }
1028 break;
1029 default:
1030 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
1031 }
1032 }
1033
1034
1035 void
1036 _mesa_GetMapiv( GLenum target, GLenum query, GLint *v )
1037 {
1038 GET_CURRENT_CONTEXT(ctx);
1039 GLuint i, n;
1040 GLfloat *data;
1041 ASSERT_OUTSIDE_BEGIN_END(ctx);
1042
1043 switch (query) {
1044 case GL_COEFF:
1045 switch (target) {
1046 case GL_MAP1_COLOR_4:
1047 data = ctx->EvalMap.Map1Color4.Points;
1048 n = ctx->EvalMap.Map1Color4.Order * 4;
1049 break;
1050 case GL_MAP1_INDEX:
1051 data = ctx->EvalMap.Map1Index.Points;
1052 n = ctx->EvalMap.Map1Index.Order;
1053 break;
1054 case GL_MAP1_NORMAL:
1055 data = ctx->EvalMap.Map1Normal.Points;
1056 n = ctx->EvalMap.Map1Normal.Order * 3;
1057 break;
1058 case GL_MAP1_TEXTURE_COORD_1:
1059 data = ctx->EvalMap.Map1Texture1.Points;
1060 n = ctx->EvalMap.Map1Texture1.Order * 1;
1061 break;
1062 case GL_MAP1_TEXTURE_COORD_2:
1063 data = ctx->EvalMap.Map1Texture2.Points;
1064 n = ctx->EvalMap.Map1Texture2.Order * 2;
1065 break;
1066 case GL_MAP1_TEXTURE_COORD_3:
1067 data = ctx->EvalMap.Map1Texture3.Points;
1068 n = ctx->EvalMap.Map1Texture3.Order * 3;
1069 break;
1070 case GL_MAP1_TEXTURE_COORD_4:
1071 data = ctx->EvalMap.Map1Texture4.Points;
1072 n = ctx->EvalMap.Map1Texture4.Order * 4;
1073 break;
1074 case GL_MAP1_VERTEX_3:
1075 data = ctx->EvalMap.Map1Vertex3.Points;
1076 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1077 break;
1078 case GL_MAP1_VERTEX_4:
1079 data = ctx->EvalMap.Map1Vertex4.Points;
1080 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1081 break;
1082 case GL_MAP2_COLOR_4:
1083 data = ctx->EvalMap.Map2Color4.Points;
1084 n = ctx->EvalMap.Map2Color4.Uorder
1085 * ctx->EvalMap.Map2Color4.Vorder * 4;
1086 break;
1087 case GL_MAP2_INDEX:
1088 data = ctx->EvalMap.Map2Index.Points;
1089 n = ctx->EvalMap.Map2Index.Uorder
1090 * ctx->EvalMap.Map2Index.Vorder;
1091 break;
1092 case GL_MAP2_NORMAL:
1093 data = ctx->EvalMap.Map2Normal.Points;
1094 n = ctx->EvalMap.Map2Normal.Uorder
1095 * ctx->EvalMap.Map2Normal.Vorder * 3;
1096 break;
1097 case GL_MAP2_TEXTURE_COORD_1:
1098 data = ctx->EvalMap.Map2Texture1.Points;
1099 n = ctx->EvalMap.Map2Texture1.Uorder
1100 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1101 break;
1102 case GL_MAP2_TEXTURE_COORD_2:
1103 data = ctx->EvalMap.Map2Texture2.Points;
1104 n = ctx->EvalMap.Map2Texture2.Uorder
1105 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1106 break;
1107 case GL_MAP2_TEXTURE_COORD_3:
1108 data = ctx->EvalMap.Map2Texture3.Points;
1109 n = ctx->EvalMap.Map2Texture3.Uorder
1110 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1111 break;
1112 case GL_MAP2_TEXTURE_COORD_4:
1113 data = ctx->EvalMap.Map2Texture4.Points;
1114 n = ctx->EvalMap.Map2Texture4.Uorder
1115 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1116 break;
1117 case GL_MAP2_VERTEX_3:
1118 data = ctx->EvalMap.Map2Vertex3.Points;
1119 n = ctx->EvalMap.Map2Vertex3.Uorder
1120 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1121 break;
1122 case GL_MAP2_VERTEX_4:
1123 data = ctx->EvalMap.Map2Vertex4.Points;
1124 n = ctx->EvalMap.Map2Vertex4.Uorder
1125 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1126 break;
1127 default:
1128 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1129 return;
1130 }
1131 if (data) {
1132 for (i=0;i<n;i++) {
1133 v[i] = ROUNDF(data[i]);
1134 }
1135 }
1136 break;
1137 case GL_ORDER:
1138 switch (target) {
1139 case GL_MAP1_COLOR_4:
1140 *v = ctx->EvalMap.Map1Color4.Order;
1141 break;
1142 case GL_MAP1_INDEX:
1143 *v = ctx->EvalMap.Map1Index.Order;
1144 break;
1145 case GL_MAP1_NORMAL:
1146 *v = ctx->EvalMap.Map1Normal.Order;
1147 break;
1148 case GL_MAP1_TEXTURE_COORD_1:
1149 *v = ctx->EvalMap.Map1Texture1.Order;
1150 break;
1151 case GL_MAP1_TEXTURE_COORD_2:
1152 *v = ctx->EvalMap.Map1Texture2.Order;
1153 break;
1154 case GL_MAP1_TEXTURE_COORD_3:
1155 *v = ctx->EvalMap.Map1Texture3.Order;
1156 break;
1157 case GL_MAP1_TEXTURE_COORD_4:
1158 *v = ctx->EvalMap.Map1Texture4.Order;
1159 break;
1160 case GL_MAP1_VERTEX_3:
1161 *v = ctx->EvalMap.Map1Vertex3.Order;
1162 break;
1163 case GL_MAP1_VERTEX_4:
1164 *v = ctx->EvalMap.Map1Vertex4.Order;
1165 break;
1166 case GL_MAP2_COLOR_4:
1167 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1168 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1169 break;
1170 case GL_MAP2_INDEX:
1171 v[0] = ctx->EvalMap.Map2Index.Uorder;
1172 v[1] = ctx->EvalMap.Map2Index.Vorder;
1173 break;
1174 case GL_MAP2_NORMAL:
1175 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1176 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1177 break;
1178 case GL_MAP2_TEXTURE_COORD_1:
1179 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1180 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1181 break;
1182 case GL_MAP2_TEXTURE_COORD_2:
1183 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1184 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1185 break;
1186 case GL_MAP2_TEXTURE_COORD_3:
1187 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1188 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1189 break;
1190 case GL_MAP2_TEXTURE_COORD_4:
1191 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1192 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1193 break;
1194 case GL_MAP2_VERTEX_3:
1195 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1196 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1197 break;
1198 case GL_MAP2_VERTEX_4:
1199 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1200 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1201 break;
1202 default:
1203 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1204 return;
1205 }
1206 break;
1207 case GL_DOMAIN:
1208 switch (target) {
1209 case GL_MAP1_COLOR_4:
1210 v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
1211 v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
1212 break;
1213 case GL_MAP1_INDEX:
1214 v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
1215 v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
1216 break;
1217 case GL_MAP1_NORMAL:
1218 v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
1219 v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
1220 break;
1221 case GL_MAP1_TEXTURE_COORD_1:
1222 v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
1223 v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
1224 break;
1225 case GL_MAP1_TEXTURE_COORD_2:
1226 v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
1227 v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
1228 break;
1229 case GL_MAP1_TEXTURE_COORD_3:
1230 v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
1231 v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
1232 break;
1233 case GL_MAP1_TEXTURE_COORD_4:
1234 v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
1235 v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
1236 break;
1237 case GL_MAP1_VERTEX_3:
1238 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
1239 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
1240 break;
1241 case GL_MAP1_VERTEX_4:
1242 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
1243 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
1244 break;
1245 case GL_MAP2_COLOR_4:
1246 v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
1247 v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
1248 v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
1249 v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
1250 break;
1251 case GL_MAP2_INDEX:
1252 v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
1253 v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
1254 v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
1255 v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
1256 break;
1257 case GL_MAP2_NORMAL:
1258 v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
1259 v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
1260 v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
1261 v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
1262 break;
1263 case GL_MAP2_TEXTURE_COORD_1:
1264 v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
1265 v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
1266 v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
1267 v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
1268 break;
1269 case GL_MAP2_TEXTURE_COORD_2:
1270 v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
1271 v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
1272 v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
1273 v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
1274 break;
1275 case GL_MAP2_TEXTURE_COORD_3:
1276 v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
1277 v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
1278 v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
1279 v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
1280 break;
1281 case GL_MAP2_TEXTURE_COORD_4:
1282 v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
1283 v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
1284 v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
1285 v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
1286 break;
1287 case GL_MAP2_VERTEX_3:
1288 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
1289 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
1290 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
1291 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
1292 break;
1293 case GL_MAP2_VERTEX_4:
1294 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
1295 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
1296 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
1297 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
1298 break;
1299 default:
1300 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1301 }
1302 break;
1303 default:
1304 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
1305 }
1306 }
1307
1308
1309
1310 void
1311 _mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
1312 {
1313 GET_CURRENT_CONTEXT(ctx);
1314 ASSERT_OUTSIDE_BEGIN_END(ctx);
1315
1316 if (un<1) {
1317 _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
1318 return;
1319 }
1320 FLUSH_VERTICES(ctx, _NEW_EVAL);
1321 ctx->Eval.MapGrid1un = un;
1322 ctx->Eval.MapGrid1u1 = u1;
1323 ctx->Eval.MapGrid1u2 = u2;
1324 ctx->Eval.MapGrid1du = (u2 - u1) / (GLfloat) un;
1325 }
1326
1327
1328 void
1329 _mesa_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
1330 {
1331 _mesa_MapGrid1f( un, u1, u2 );
1332 }
1333
1334
1335 void
1336 _mesa_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
1337 GLint vn, GLfloat v1, GLfloat v2 )
1338 {
1339 GET_CURRENT_CONTEXT(ctx);
1340 ASSERT_OUTSIDE_BEGIN_END(ctx);
1341
1342 if (un<1) {
1343 _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
1344 return;
1345 }
1346 if (vn<1) {
1347 _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
1348 return;
1349 }
1350
1351 FLUSH_VERTICES(ctx, _NEW_EVAL);
1352 ctx->Eval.MapGrid2un = un;
1353 ctx->Eval.MapGrid2u1 = u1;
1354 ctx->Eval.MapGrid2u2 = u2;
1355 ctx->Eval.MapGrid2du = (u2 - u1) / (GLfloat) un;
1356 ctx->Eval.MapGrid2vn = vn;
1357 ctx->Eval.MapGrid2v1 = v1;
1358 ctx->Eval.MapGrid2v2 = v2;
1359 ctx->Eval.MapGrid2dv = (v2 - v1) / (GLfloat) vn;
1360 }
1361
1362
1363 void
1364 _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
1365 GLint vn, GLdouble v1, GLdouble v2 )
1366 {
1367 _mesa_MapGrid2f( un, u1, u2, vn, v1, v2 );
1368 }