projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Major rework of tnl module
[mesa.git] / src / mesa / main / eval.c
1 /* $Id: eval.c,v 1.17 2000/12/26 05:09:28 keithw Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.5
6 *
7 * Copyright (C) 1999-2000 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 *gl_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 *gl_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 *gl_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 *gl_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 gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
261 return;
262 }
263 if (uorder < 1 || uorder > MAX_EVAL_ORDER) {
264 gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
265 return;
266 }
267 if (!points) {
268 gl_error( ctx, GL_INVALID_VALUE, "glMap1(points)" );
269 return;
270 }
271
272 k = _mesa_evaluator_components( target );
273 if (k == 0) {
274 gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
275 }
276
277 if (ustride < k) {
278 gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
279 return;
280 }
281
282 switch (target) {
283 case GL_MAP1_VERTEX_3:
284 map = &ctx->EvalMap.Map1Vertex3;
285 break;
286 case GL_MAP1_VERTEX_4:
287 map = &ctx->EvalMap.Map1Vertex4;
288 break;
289 case GL_MAP1_INDEX:
290 map = &ctx->EvalMap.Map1Index;
291 break;
292 case GL_MAP1_COLOR_4:
293 map = &ctx->EvalMap.Map1Color4;
294 break;
295 case GL_MAP1_NORMAL:
296 map = &ctx->EvalMap.Map1Normal;
297 break;
298 case GL_MAP1_TEXTURE_COORD_1:
299 map = &ctx->EvalMap.Map1Texture1;
300 break;
301 case GL_MAP1_TEXTURE_COORD_2:
302 map = &ctx->EvalMap.Map1Texture2;
303 break;
304 case GL_MAP1_TEXTURE_COORD_3:
305 map = &ctx->EvalMap.Map1Texture3;
306 break;
307 case GL_MAP1_TEXTURE_COORD_4:
308 map = &ctx->EvalMap.Map1Texture4;
309 break;
310 default:
311 gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
312 return;
313 }
314
315 /* make copy of the control points */
316 if (type == GL_FLOAT)
317 pnts = gl_copy_map_points1f(target, ustride, uorder, (GLfloat*) points);
318 else
319 pnts = gl_copy_map_points1d(target, ustride, uorder, (GLdouble*) points);
320
321
322 FLUSH_VERTICES(ctx, _NEW_EVAL);
323 map->Order = uorder;
324 map->u1 = u1;
325 map->u2 = u2;
326 map->du = 1.0 / (u2 - u1);
327 if (map->Points)
328 FREE( map->Points );
329 map->Points = pnts;
330 }
331
332
333
334 void
335 _mesa_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
336 GLint order, const GLfloat *points )
337 {
338 map1(target, u1, u2, stride, order, points, GL_FLOAT);
339 }
340
341
342 void
343 _mesa_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
344 GLint order, const GLdouble *points )
345 {
346 map1(target, u1, u2, stride, order, points, GL_DOUBLE);
347 }
348
349
350 static void
351 map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
352 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
353 const GLvoid *points, GLenum type )
354 {
355 GET_CURRENT_CONTEXT(ctx);
356 GLint k;
357 GLfloat *pnts;
358 struct gl_2d_map *map = 0;
359 ASSERT_OUTSIDE_BEGIN_END(ctx);
360
361 if (u1==u2) {
362 gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
363 return;
364 }
365
366 if (v1==v2) {
367 gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
368 return;
369 }
370
371 if (uorder<1 || uorder>MAX_EVAL_ORDER) {
372 gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
373 return;
374 }
375
376 if (vorder<1 || vorder>MAX_EVAL_ORDER) {
377 gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
378 return;
379 }
380
381 k = _mesa_evaluator_components( target );
382 if (k==0) {
383 gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
384 }
385
386 if (ustride < k) {
387 gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
388 return;
389 }
390 if (vstride < k) {
391 gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
392 return;
393 }
394
395 switch (target) {
396 case GL_MAP2_VERTEX_3:
397 map = &ctx->EvalMap.Map2Vertex3;
398 break;
399 case GL_MAP2_VERTEX_4:
400 map = &ctx->EvalMap.Map2Vertex4;
401 break;
402 case GL_MAP2_INDEX:
403 map = &ctx->EvalMap.Map2Index;
404 break;
405 case GL_MAP2_COLOR_4:
406 map = &ctx->EvalMap.Map2Color4;
407 break;
408 case GL_MAP2_NORMAL:
409 map = &ctx->EvalMap.Map2Normal;
410 break;
411 case GL_MAP2_TEXTURE_COORD_1:
412 map = &ctx->EvalMap.Map2Texture1;
413 break;
414 case GL_MAP2_TEXTURE_COORD_2:
415 map = &ctx->EvalMap.Map2Texture2;
416 break;
417 case GL_MAP2_TEXTURE_COORD_3:
418 map = &ctx->EvalMap.Map2Texture3;
419 break;
420 case GL_MAP2_TEXTURE_COORD_4:
421 map = &ctx->EvalMap.Map2Texture4;
422 break;
423 default:
424 gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
425 return;
426 }
427
428 /* make copy of the control points */
429 if (type == GL_FLOAT)
430 pnts = gl_copy_map_points2f(target, ustride, uorder,
431 vstride, vorder, (GLfloat*) points);
432 else
433 pnts = gl_copy_map_points2d(target, ustride, uorder,
434 vstride, vorder, (GLdouble*) points);
435
436
437 FLUSH_VERTICES(ctx, _NEW_EVAL);
438 map->Uorder = uorder;
439 map->u1 = u1;
440 map->u2 = u2;
441 map->du = 1.0 / (u2 - u1);
442 map->Vorder = vorder;
443 map->v1 = v1;
444 map->v2 = v2;
445 map->dv = 1.0 / (v2 - v1);
446 if (map->Points)
447 FREE( map->Points );
448 map->Points = pnts;
449 }
450
451
452 void
453 _mesa_Map2f( GLenum target,
454 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
455 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
456 const GLfloat *points)
457 {
458 map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
459 points, GL_FLOAT);
460 }
461
462
463 void
464 _mesa_Map2d( GLenum target,
465 GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
466 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
467 const GLdouble *points )
468 {
469 map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
470 points, GL_DOUBLE);
471 }
472
473
474
475 void
476 _mesa_GetMapdv( GLenum target, GLenum query, GLdouble *v )
477 {
478 GET_CURRENT_CONTEXT(ctx);
479 GLint i, n;
480 GLfloat *data;
481 ASSERT_OUTSIDE_BEGIN_END(ctx);
482
483 switch (query) {
484 case GL_COEFF:
485 switch (target) {
486 case GL_MAP1_COLOR_4:
487 data = ctx->EvalMap.Map1Color4.Points;
488 n = ctx->EvalMap.Map1Color4.Order * 4;
489 break;
490 case GL_MAP1_INDEX:
491 data = ctx->EvalMap.Map1Index.Points;
492 n = ctx->EvalMap.Map1Index.Order;
493 break;
494 case GL_MAP1_NORMAL:
495 data = ctx->EvalMap.Map1Normal.Points;
496 n = ctx->EvalMap.Map1Normal.Order * 3;
497 break;
498 case GL_MAP1_TEXTURE_COORD_1:
499 data = ctx->EvalMap.Map1Texture1.Points;
500 n = ctx->EvalMap.Map1Texture1.Order * 1;
501 break;
502 case GL_MAP1_TEXTURE_COORD_2:
503 data = ctx->EvalMap.Map1Texture2.Points;
504 n = ctx->EvalMap.Map1Texture2.Order * 2;
505 break;
506 case GL_MAP1_TEXTURE_COORD_3:
507 data = ctx->EvalMap.Map1Texture3.Points;
508 n = ctx->EvalMap.Map1Texture3.Order * 3;
509 break;
510 case GL_MAP1_TEXTURE_COORD_4:
511 data = ctx->EvalMap.Map1Texture4.Points;
512 n = ctx->EvalMap.Map1Texture4.Order * 4;
513 break;
514 case GL_MAP1_VERTEX_3:
515 data = ctx->EvalMap.Map1Vertex3.Points;
516 n = ctx->EvalMap.Map1Vertex3.Order * 3;
517 break;
518 case GL_MAP1_VERTEX_4:
519 data = ctx->EvalMap.Map1Vertex4.Points;
520 n = ctx->EvalMap.Map1Vertex4.Order * 4;
521 break;
522 case GL_MAP2_COLOR_4:
523 data = ctx->EvalMap.Map2Color4.Points;
524 n = ctx->EvalMap.Map2Color4.Uorder
525 * ctx->EvalMap.Map2Color4.Vorder * 4;
526 break;
527 case GL_MAP2_INDEX:
528 data = ctx->EvalMap.Map2Index.Points;
529 n = ctx->EvalMap.Map2Index.Uorder
530 * ctx->EvalMap.Map2Index.Vorder;
531 break;
532 case GL_MAP2_NORMAL:
533 data = ctx->EvalMap.Map2Normal.Points;
534 n = ctx->EvalMap.Map2Normal.Uorder
535 * ctx->EvalMap.Map2Normal.Vorder * 3;
536 break;
537 case GL_MAP2_TEXTURE_COORD_1:
538 data = ctx->EvalMap.Map2Texture1.Points;
539 n = ctx->EvalMap.Map2Texture1.Uorder
540 * ctx->EvalMap.Map2Texture1.Vorder * 1;
541 break;
542 case GL_MAP2_TEXTURE_COORD_2:
543 data = ctx->EvalMap.Map2Texture2.Points;
544 n = ctx->EvalMap.Map2Texture2.Uorder
545 * ctx->EvalMap.Map2Texture2.Vorder * 2;
546 break;
547 case GL_MAP2_TEXTURE_COORD_3:
548 data = ctx->EvalMap.Map2Texture3.Points;
549 n = ctx->EvalMap.Map2Texture3.Uorder
550 * ctx->EvalMap.Map2Texture3.Vorder * 3;
551 break;
552 case GL_MAP2_TEXTURE_COORD_4:
553 data = ctx->EvalMap.Map2Texture4.Points;
554 n = ctx->EvalMap.Map2Texture4.Uorder
555 * ctx->EvalMap.Map2Texture4.Vorder * 4;
556 break;
557 case GL_MAP2_VERTEX_3:
558 data = ctx->EvalMap.Map2Vertex3.Points;
559 n = ctx->EvalMap.Map2Vertex3.Uorder
560 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
561 break;
562 case GL_MAP2_VERTEX_4:
563 data = ctx->EvalMap.Map2Vertex4.Points;
564 n = ctx->EvalMap.Map2Vertex4.Uorder
565 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
566 break;
567 default:
568 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
569 return;
570 }
571 if (data) {
572 for (i=0;i<n;i++) {
573 v[i] = data[i];
574 }
575 }
576 break;
577 case GL_ORDER:
578 switch (target) {
579 case GL_MAP1_COLOR_4:
580 *v = ctx->EvalMap.Map1Color4.Order;
581 break;
582 case GL_MAP1_INDEX:
583 *v = ctx->EvalMap.Map1Index.Order;
584 break;
585 case GL_MAP1_NORMAL:
586 *v = ctx->EvalMap.Map1Normal.Order;
587 break;
588 case GL_MAP1_TEXTURE_COORD_1:
589 *v = ctx->EvalMap.Map1Texture1.Order;
590 break;
591 case GL_MAP1_TEXTURE_COORD_2:
592 *v = ctx->EvalMap.Map1Texture2.Order;
593 break;
594 case GL_MAP1_TEXTURE_COORD_3:
595 *v = ctx->EvalMap.Map1Texture3.Order;
596 break;
597 case GL_MAP1_TEXTURE_COORD_4:
598 *v = ctx->EvalMap.Map1Texture4.Order;
599 break;
600 case GL_MAP1_VERTEX_3:
601 *v = ctx->EvalMap.Map1Vertex3.Order;
602 break;
603 case GL_MAP1_VERTEX_4:
604 *v = ctx->EvalMap.Map1Vertex4.Order;
605 break;
606 case GL_MAP2_COLOR_4:
607 v[0] = ctx->EvalMap.Map2Color4.Uorder;
608 v[1] = ctx->EvalMap.Map2Color4.Vorder;
609 break;
610 case GL_MAP2_INDEX:
611 v[0] = ctx->EvalMap.Map2Index.Uorder;
612 v[1] = ctx->EvalMap.Map2Index.Vorder;
613 break;
614 case GL_MAP2_NORMAL:
615 v[0] = ctx->EvalMap.Map2Normal.Uorder;
616 v[1] = ctx->EvalMap.Map2Normal.Vorder;
617 break;
618 case GL_MAP2_TEXTURE_COORD_1:
619 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
620 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
621 break;
622 case GL_MAP2_TEXTURE_COORD_2:
623 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
624 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
625 break;
626 case GL_MAP2_TEXTURE_COORD_3:
627 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
628 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
629 break;
630 case GL_MAP2_TEXTURE_COORD_4:
631 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
632 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
633 break;
634 case GL_MAP2_VERTEX_3:
635 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
636 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
637 break;
638 case GL_MAP2_VERTEX_4:
639 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
640 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
641 break;
642 default:
643 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
644 return;
645 }
646 break;
647 case GL_DOMAIN:
648 switch (target) {
649 case GL_MAP1_COLOR_4:
650 v[0] = ctx->EvalMap.Map1Color4.u1;
651 v[1] = ctx->EvalMap.Map1Color4.u2;
652 break;
653 case GL_MAP1_INDEX:
654 v[0] = ctx->EvalMap.Map1Index.u1;
655 v[1] = ctx->EvalMap.Map1Index.u2;
656 break;
657 case GL_MAP1_NORMAL:
658 v[0] = ctx->EvalMap.Map1Normal.u1;
659 v[1] = ctx->EvalMap.Map1Normal.u2;
660 break;
661 case GL_MAP1_TEXTURE_COORD_1:
662 v[0] = ctx->EvalMap.Map1Texture1.u1;
663 v[1] = ctx->EvalMap.Map1Texture1.u2;
664 break;
665 case GL_MAP1_TEXTURE_COORD_2:
666 v[0] = ctx->EvalMap.Map1Texture2.u1;
667 v[1] = ctx->EvalMap.Map1Texture2.u2;
668 break;
669 case GL_MAP1_TEXTURE_COORD_3:
670 v[0] = ctx->EvalMap.Map1Texture3.u1;
671 v[1] = ctx->EvalMap.Map1Texture3.u2;
672 break;
673 case GL_MAP1_TEXTURE_COORD_4:
674 v[0] = ctx->EvalMap.Map1Texture4.u1;
675 v[1] = ctx->EvalMap.Map1Texture4.u2;
676 break;
677 case GL_MAP1_VERTEX_3:
678 v[0] = ctx->EvalMap.Map1Vertex3.u1;
679 v[1] = ctx->EvalMap.Map1Vertex3.u2;
680 break;
681 case GL_MAP1_VERTEX_4:
682 v[0] = ctx->EvalMap.Map1Vertex4.u1;
683 v[1] = ctx->EvalMap.Map1Vertex4.u2;
684 break;
685 case GL_MAP2_COLOR_4:
686 v[0] = ctx->EvalMap.Map2Color4.u1;
687 v[1] = ctx->EvalMap.Map2Color4.u2;
688 v[2] = ctx->EvalMap.Map2Color4.v1;
689 v[3] = ctx->EvalMap.Map2Color4.v2;
690 break;
691 case GL_MAP2_INDEX:
692 v[0] = ctx->EvalMap.Map2Index.u1;
693 v[1] = ctx->EvalMap.Map2Index.u2;
694 v[2] = ctx->EvalMap.Map2Index.v1;
695 v[3] = ctx->EvalMap.Map2Index.v2;
696 break;
697 case GL_MAP2_NORMAL:
698 v[0] = ctx->EvalMap.Map2Normal.u1;
699 v[1] = ctx->EvalMap.Map2Normal.u2;
700 v[2] = ctx->EvalMap.Map2Normal.v1;
701 v[3] = ctx->EvalMap.Map2Normal.v2;
702 break;
703 case GL_MAP2_TEXTURE_COORD_1:
704 v[0] = ctx->EvalMap.Map2Texture1.u1;
705 v[1] = ctx->EvalMap.Map2Texture1.u2;
706 v[2] = ctx->EvalMap.Map2Texture1.v1;
707 v[3] = ctx->EvalMap.Map2Texture1.v2;
708 break;
709 case GL_MAP2_TEXTURE_COORD_2:
710 v[0] = ctx->EvalMap.Map2Texture2.u1;
711 v[1] = ctx->EvalMap.Map2Texture2.u2;
712 v[2] = ctx->EvalMap.Map2Texture2.v1;
713 v[3] = ctx->EvalMap.Map2Texture2.v2;
714 break;
715 case GL_MAP2_TEXTURE_COORD_3:
716 v[0] = ctx->EvalMap.Map2Texture3.u1;
717 v[1] = ctx->EvalMap.Map2Texture3.u2;
718 v[2] = ctx->EvalMap.Map2Texture3.v1;
719 v[3] = ctx->EvalMap.Map2Texture3.v2;
720 break;
721 case GL_MAP2_TEXTURE_COORD_4:
722 v[0] = ctx->EvalMap.Map2Texture4.u1;
723 v[1] = ctx->EvalMap.Map2Texture4.u2;
724 v[2] = ctx->EvalMap.Map2Texture4.v1;
725 v[3] = ctx->EvalMap.Map2Texture4.v2;
726 break;
727 case GL_MAP2_VERTEX_3:
728 v[0] = ctx->EvalMap.Map2Vertex3.u1;
729 v[1] = ctx->EvalMap.Map2Vertex3.u2;
730 v[2] = ctx->EvalMap.Map2Vertex3.v1;
731 v[3] = ctx->EvalMap.Map2Vertex3.v2;
732 break;
733 case GL_MAP2_VERTEX_4:
734 v[0] = ctx->EvalMap.Map2Vertex4.u1;
735 v[1] = ctx->EvalMap.Map2Vertex4.u2;
736 v[2] = ctx->EvalMap.Map2Vertex4.v1;
737 v[3] = ctx->EvalMap.Map2Vertex4.v2;
738 break;
739 default:
740 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
741 }
742 break;
743 default:
744 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
745 }
746 }
747
748
749 void
750 _mesa_GetMapfv( GLenum target, GLenum query, GLfloat *v )
751 {
752 GET_CURRENT_CONTEXT(ctx);
753 GLint i, n;
754 GLfloat *data;
755 ASSERT_OUTSIDE_BEGIN_END(ctx);
756
757 switch (query) {
758 case GL_COEFF:
759 switch (target) {
760 case GL_MAP1_COLOR_4:
761 data = ctx->EvalMap.Map1Color4.Points;
762 n = ctx->EvalMap.Map1Color4.Order * 4;
763 break;
764 case GL_MAP1_INDEX:
765 data = ctx->EvalMap.Map1Index.Points;
766 n = ctx->EvalMap.Map1Index.Order;
767 break;
768 case GL_MAP1_NORMAL:
769 data = ctx->EvalMap.Map1Normal.Points;
770 n = ctx->EvalMap.Map1Normal.Order * 3;
771 break;
772 case GL_MAP1_TEXTURE_COORD_1:
773 data = ctx->EvalMap.Map1Texture1.Points;
774 n = ctx->EvalMap.Map1Texture1.Order * 1;
775 break;
776 case GL_MAP1_TEXTURE_COORD_2:
777 data = ctx->EvalMap.Map1Texture2.Points;
778 n = ctx->EvalMap.Map1Texture2.Order * 2;
779 break;
780 case GL_MAP1_TEXTURE_COORD_3:
781 data = ctx->EvalMap.Map1Texture3.Points;
782 n = ctx->EvalMap.Map1Texture3.Order * 3;
783 break;
784 case GL_MAP1_TEXTURE_COORD_4:
785 data = ctx->EvalMap.Map1Texture4.Points;
786 n = ctx->EvalMap.Map1Texture4.Order * 4;
787 break;
788 case GL_MAP1_VERTEX_3:
789 data = ctx->EvalMap.Map1Vertex3.Points;
790 n = ctx->EvalMap.Map1Vertex3.Order * 3;
791 break;
792 case GL_MAP1_VERTEX_4:
793 data = ctx->EvalMap.Map1Vertex4.Points;
794 n = ctx->EvalMap.Map1Vertex4.Order * 4;
795 break;
796 case GL_MAP2_COLOR_4:
797 data = ctx->EvalMap.Map2Color4.Points;
798 n = ctx->EvalMap.Map2Color4.Uorder
799 * ctx->EvalMap.Map2Color4.Vorder * 4;
800 break;
801 case GL_MAP2_INDEX:
802 data = ctx->EvalMap.Map2Index.Points;
803 n = ctx->EvalMap.Map2Index.Uorder
804 * ctx->EvalMap.Map2Index.Vorder;
805 break;
806 case GL_MAP2_NORMAL:
807 data = ctx->EvalMap.Map2Normal.Points;
808 n = ctx->EvalMap.Map2Normal.Uorder
809 * ctx->EvalMap.Map2Normal.Vorder * 3;
810 break;
811 case GL_MAP2_TEXTURE_COORD_1:
812 data = ctx->EvalMap.Map2Texture1.Points;
813 n = ctx->EvalMap.Map2Texture1.Uorder
814 * ctx->EvalMap.Map2Texture1.Vorder * 1;
815 break;
816 case GL_MAP2_TEXTURE_COORD_2:
817 data = ctx->EvalMap.Map2Texture2.Points;
818 n = ctx->EvalMap.Map2Texture2.Uorder
819 * ctx->EvalMap.Map2Texture2.Vorder * 2;
820 break;
821 case GL_MAP2_TEXTURE_COORD_3:
822 data = ctx->EvalMap.Map2Texture3.Points;
823 n = ctx->EvalMap.Map2Texture3.Uorder
824 * ctx->EvalMap.Map2Texture3.Vorder * 3;
825 break;
826 case GL_MAP2_TEXTURE_COORD_4:
827 data = ctx->EvalMap.Map2Texture4.Points;
828 n = ctx->EvalMap.Map2Texture4.Uorder
829 * ctx->EvalMap.Map2Texture4.Vorder * 4;
830 break;
831 case GL_MAP2_VERTEX_3:
832 data = ctx->EvalMap.Map2Vertex3.Points;
833 n = ctx->EvalMap.Map2Vertex3.Uorder
834 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
835 break;
836 case GL_MAP2_VERTEX_4:
837 data = ctx->EvalMap.Map2Vertex4.Points;
838 n = ctx->EvalMap.Map2Vertex4.Uorder
839 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
840 break;
841 default:
842 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
843 return;
844 }
845 if (data) {
846 for (i=0;i<n;i++) {
847 v[i] = data[i];
848 }
849 }
850 break;
851 case GL_ORDER:
852 switch (target) {
853 case GL_MAP1_COLOR_4:
854 *v = ctx->EvalMap.Map1Color4.Order;
855 break;
856 case GL_MAP1_INDEX:
857 *v = ctx->EvalMap.Map1Index.Order;
858 break;
859 case GL_MAP1_NORMAL:
860 *v = ctx->EvalMap.Map1Normal.Order;
861 break;
862 case GL_MAP1_TEXTURE_COORD_1:
863 *v = ctx->EvalMap.Map1Texture1.Order;
864 break;
865 case GL_MAP1_TEXTURE_COORD_2:
866 *v = ctx->EvalMap.Map1Texture2.Order;
867 break;
868 case GL_MAP1_TEXTURE_COORD_3:
869 *v = ctx->EvalMap.Map1Texture3.Order;
870 break;
871 case GL_MAP1_TEXTURE_COORD_4:
872 *v = ctx->EvalMap.Map1Texture4.Order;
873 break;
874 case GL_MAP1_VERTEX_3:
875 *v = ctx->EvalMap.Map1Vertex3.Order;
876 break;
877 case GL_MAP1_VERTEX_4:
878 *v = ctx->EvalMap.Map1Vertex4.Order;
879 break;
880 case GL_MAP2_COLOR_4:
881 v[0] = ctx->EvalMap.Map2Color4.Uorder;
882 v[1] = ctx->EvalMap.Map2Color4.Vorder;
883 break;
884 case GL_MAP2_INDEX:
885 v[0] = ctx->EvalMap.Map2Index.Uorder;
886 v[1] = ctx->EvalMap.Map2Index.Vorder;
887 break;
888 case GL_MAP2_NORMAL:
889 v[0] = ctx->EvalMap.Map2Normal.Uorder;
890 v[1] = ctx->EvalMap.Map2Normal.Vorder;
891 break;
892 case GL_MAP2_TEXTURE_COORD_1:
893 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
894 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
895 break;
896 case GL_MAP2_TEXTURE_COORD_2:
897 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
898 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
899 break;
900 case GL_MAP2_TEXTURE_COORD_3:
901 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
902 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
903 break;
904 case GL_MAP2_TEXTURE_COORD_4:
905 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
906 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
907 break;
908 case GL_MAP2_VERTEX_3:
909 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
910 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
911 break;
912 case GL_MAP2_VERTEX_4:
913 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
914 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
915 break;
916 default:
917 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
918 return;
919 }
920 break;
921 case GL_DOMAIN:
922 switch (target) {
923 case GL_MAP1_COLOR_4:
924 v[0] = ctx->EvalMap.Map1Color4.u1;
925 v[1] = ctx->EvalMap.Map1Color4.u2;
926 break;
927 case GL_MAP1_INDEX:
928 v[0] = ctx->EvalMap.Map1Index.u1;
929 v[1] = ctx->EvalMap.Map1Index.u2;
930 break;
931 case GL_MAP1_NORMAL:
932 v[0] = ctx->EvalMap.Map1Normal.u1;
933 v[1] = ctx->EvalMap.Map1Normal.u2;
934 break;
935 case GL_MAP1_TEXTURE_COORD_1:
936 v[0] = ctx->EvalMap.Map1Texture1.u1;
937 v[1] = ctx->EvalMap.Map1Texture1.u2;
938 break;
939 case GL_MAP1_TEXTURE_COORD_2:
940 v[0] = ctx->EvalMap.Map1Texture2.u1;
941 v[1] = ctx->EvalMap.Map1Texture2.u2;
942 break;
943 case GL_MAP1_TEXTURE_COORD_3:
944 v[0] = ctx->EvalMap.Map1Texture3.u1;
945 v[1] = ctx->EvalMap.Map1Texture3.u2;
946 break;
947 case GL_MAP1_TEXTURE_COORD_4:
948 v[0] = ctx->EvalMap.Map1Texture4.u1;
949 v[1] = ctx->EvalMap.Map1Texture4.u2;
950 break;
951 case GL_MAP1_VERTEX_3:
952 v[0] = ctx->EvalMap.Map1Vertex3.u1;
953 v[1] = ctx->EvalMap.Map1Vertex3.u2;
954 break;
955 case GL_MAP1_VERTEX_4:
956 v[0] = ctx->EvalMap.Map1Vertex4.u1;
957 v[1] = ctx->EvalMap.Map1Vertex4.u2;
958 break;
959 case GL_MAP2_COLOR_4:
960 v[0] = ctx->EvalMap.Map2Color4.u1;
961 v[1] = ctx->EvalMap.Map2Color4.u2;
962 v[2] = ctx->EvalMap.Map2Color4.v1;
963 v[3] = ctx->EvalMap.Map2Color4.v2;
964 break;
965 case GL_MAP2_INDEX:
966 v[0] = ctx->EvalMap.Map2Index.u1;
967 v[1] = ctx->EvalMap.Map2Index.u2;
968 v[2] = ctx->EvalMap.Map2Index.v1;
969 v[3] = ctx->EvalMap.Map2Index.v2;
970 break;
971 case GL_MAP2_NORMAL:
972 v[0] = ctx->EvalMap.Map2Normal.u1;
973 v[1] = ctx->EvalMap.Map2Normal.u2;
974 v[2] = ctx->EvalMap.Map2Normal.v1;
975 v[3] = ctx->EvalMap.Map2Normal.v2;
976 break;
977 case GL_MAP2_TEXTURE_COORD_1:
978 v[0] = ctx->EvalMap.Map2Texture1.u1;
979 v[1] = ctx->EvalMap.Map2Texture1.u2;
980 v[2] = ctx->EvalMap.Map2Texture1.v1;
981 v[3] = ctx->EvalMap.Map2Texture1.v2;
982 break;
983 case GL_MAP2_TEXTURE_COORD_2:
984 v[0] = ctx->EvalMap.Map2Texture2.u1;
985 v[1] = ctx->EvalMap.Map2Texture2.u2;
986 v[2] = ctx->EvalMap.Map2Texture2.v1;
987 v[3] = ctx->EvalMap.Map2Texture2.v2;
988 break;
989 case GL_MAP2_TEXTURE_COORD_3:
990 v[0] = ctx->EvalMap.Map2Texture3.u1;
991 v[1] = ctx->EvalMap.Map2Texture3.u2;
992 v[2] = ctx->EvalMap.Map2Texture3.v1;
993 v[3] = ctx->EvalMap.Map2Texture3.v2;
994 break;
995 case GL_MAP2_TEXTURE_COORD_4:
996 v[0] = ctx->EvalMap.Map2Texture4.u1;
997 v[1] = ctx->EvalMap.Map2Texture4.u2;
998 v[2] = ctx->EvalMap.Map2Texture4.v1;
999 v[3] = ctx->EvalMap.Map2Texture4.v2;
1000 break;
1001 case GL_MAP2_VERTEX_3:
1002 v[0] = ctx->EvalMap.Map2Vertex3.u1;
1003 v[1] = ctx->EvalMap.Map2Vertex3.u2;
1004 v[2] = ctx->EvalMap.Map2Vertex3.v1;
1005 v[3] = ctx->EvalMap.Map2Vertex3.v2;
1006 break;
1007 case GL_MAP2_VERTEX_4:
1008 v[0] = ctx->EvalMap.Map2Vertex4.u1;
1009 v[1] = ctx->EvalMap.Map2Vertex4.u2;
1010 v[2] = ctx->EvalMap.Map2Vertex4.v1;
1011 v[3] = ctx->EvalMap.Map2Vertex4.v2;
1012 break;
1013 default:
1014 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1015 }
1016 break;
1017 default:
1018 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
1019 }
1020 }
1021
1022
1023 void
1024 _mesa_GetMapiv( GLenum target, GLenum query, GLint *v )
1025 {
1026 GET_CURRENT_CONTEXT(ctx);
1027 GLuint i, n;
1028 GLfloat *data;
1029 ASSERT_OUTSIDE_BEGIN_END(ctx);
1030
1031 switch (query) {
1032 case GL_COEFF:
1033 switch (target) {
1034 case GL_MAP1_COLOR_4:
1035 data = ctx->EvalMap.Map1Color4.Points;
1036 n = ctx->EvalMap.Map1Color4.Order * 4;
1037 break;
1038 case GL_MAP1_INDEX:
1039 data = ctx->EvalMap.Map1Index.Points;
1040 n = ctx->EvalMap.Map1Index.Order;
1041 break;
1042 case GL_MAP1_NORMAL:
1043 data = ctx->EvalMap.Map1Normal.Points;
1044 n = ctx->EvalMap.Map1Normal.Order * 3;
1045 break;
1046 case GL_MAP1_TEXTURE_COORD_1:
1047 data = ctx->EvalMap.Map1Texture1.Points;
1048 n = ctx->EvalMap.Map1Texture1.Order * 1;
1049 break;
1050 case GL_MAP1_TEXTURE_COORD_2:
1051 data = ctx->EvalMap.Map1Texture2.Points;
1052 n = ctx->EvalMap.Map1Texture2.Order * 2;
1053 break;
1054 case GL_MAP1_TEXTURE_COORD_3:
1055 data = ctx->EvalMap.Map1Texture3.Points;
1056 n = ctx->EvalMap.Map1Texture3.Order * 3;
1057 break;
1058 case GL_MAP1_TEXTURE_COORD_4:
1059 data = ctx->EvalMap.Map1Texture4.Points;
1060 n = ctx->EvalMap.Map1Texture4.Order * 4;
1061 break;
1062 case GL_MAP1_VERTEX_3:
1063 data = ctx->EvalMap.Map1Vertex3.Points;
1064 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1065 break;
1066 case GL_MAP1_VERTEX_4:
1067 data = ctx->EvalMap.Map1Vertex4.Points;
1068 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1069 break;
1070 case GL_MAP2_COLOR_4:
1071 data = ctx->EvalMap.Map2Color4.Points;
1072 n = ctx->EvalMap.Map2Color4.Uorder
1073 * ctx->EvalMap.Map2Color4.Vorder * 4;
1074 break;
1075 case GL_MAP2_INDEX:
1076 data = ctx->EvalMap.Map2Index.Points;
1077 n = ctx->EvalMap.Map2Index.Uorder
1078 * ctx->EvalMap.Map2Index.Vorder;
1079 break;
1080 case GL_MAP2_NORMAL:
1081 data = ctx->EvalMap.Map2Normal.Points;
1082 n = ctx->EvalMap.Map2Normal.Uorder
1083 * ctx->EvalMap.Map2Normal.Vorder * 3;
1084 break;
1085 case GL_MAP2_TEXTURE_COORD_1:
1086 data = ctx->EvalMap.Map2Texture1.Points;
1087 n = ctx->EvalMap.Map2Texture1.Uorder
1088 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1089 break;
1090 case GL_MAP2_TEXTURE_COORD_2:
1091 data = ctx->EvalMap.Map2Texture2.Points;
1092 n = ctx->EvalMap.Map2Texture2.Uorder
1093 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1094 break;
1095 case GL_MAP2_TEXTURE_COORD_3:
1096 data = ctx->EvalMap.Map2Texture3.Points;
1097 n = ctx->EvalMap.Map2Texture3.Uorder
1098 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1099 break;
1100 case GL_MAP2_TEXTURE_COORD_4:
1101 data = ctx->EvalMap.Map2Texture4.Points;
1102 n = ctx->EvalMap.Map2Texture4.Uorder
1103 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1104 break;
1105 case GL_MAP2_VERTEX_3:
1106 data = ctx->EvalMap.Map2Vertex3.Points;
1107 n = ctx->EvalMap.Map2Vertex3.Uorder
1108 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1109 break;
1110 case GL_MAP2_VERTEX_4:
1111 data = ctx->EvalMap.Map2Vertex4.Points;
1112 n = ctx->EvalMap.Map2Vertex4.Uorder
1113 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1114 break;
1115 default:
1116 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1117 return;
1118 }
1119 if (data) {
1120 for (i=0;i<n;i++) {
1121 v[i] = ROUNDF(data[i]);
1122 }
1123 }
1124 break;
1125 case GL_ORDER:
1126 switch (target) {
1127 case GL_MAP1_COLOR_4:
1128 *v = ctx->EvalMap.Map1Color4.Order;
1129 break;
1130 case GL_MAP1_INDEX:
1131 *v = ctx->EvalMap.Map1Index.Order;
1132 break;
1133 case GL_MAP1_NORMAL:
1134 *v = ctx->EvalMap.Map1Normal.Order;
1135 break;
1136 case GL_MAP1_TEXTURE_COORD_1:
1137 *v = ctx->EvalMap.Map1Texture1.Order;
1138 break;
1139 case GL_MAP1_TEXTURE_COORD_2:
1140 *v = ctx->EvalMap.Map1Texture2.Order;
1141 break;
1142 case GL_MAP1_TEXTURE_COORD_3:
1143 *v = ctx->EvalMap.Map1Texture3.Order;
1144 break;
1145 case GL_MAP1_TEXTURE_COORD_4:
1146 *v = ctx->EvalMap.Map1Texture4.Order;
1147 break;
1148 case GL_MAP1_VERTEX_3:
1149 *v = ctx->EvalMap.Map1Vertex3.Order;
1150 break;
1151 case GL_MAP1_VERTEX_4:
1152 *v = ctx->EvalMap.Map1Vertex4.Order;
1153 break;
1154 case GL_MAP2_COLOR_4:
1155 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1156 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1157 break;
1158 case GL_MAP2_INDEX:
1159 v[0] = ctx->EvalMap.Map2Index.Uorder;
1160 v[1] = ctx->EvalMap.Map2Index.Vorder;
1161 break;
1162 case GL_MAP2_NORMAL:
1163 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1164 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1165 break;
1166 case GL_MAP2_TEXTURE_COORD_1:
1167 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1168 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1169 break;
1170 case GL_MAP2_TEXTURE_COORD_2:
1171 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1172 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1173 break;
1174 case GL_MAP2_TEXTURE_COORD_3:
1175 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1176 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1177 break;
1178 case GL_MAP2_TEXTURE_COORD_4:
1179 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1180 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1181 break;
1182 case GL_MAP2_VERTEX_3:
1183 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1184 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1185 break;
1186 case GL_MAP2_VERTEX_4:
1187 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1188 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1189 break;
1190 default:
1191 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1192 return;
1193 }
1194 break;
1195 case GL_DOMAIN:
1196 switch (target) {
1197 case GL_MAP1_COLOR_4:
1198 v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
1199 v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
1200 break;
1201 case GL_MAP1_INDEX:
1202 v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
1203 v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
1204 break;
1205 case GL_MAP1_NORMAL:
1206 v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
1207 v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
1208 break;
1209 case GL_MAP1_TEXTURE_COORD_1:
1210 v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
1211 v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
1212 break;
1213 case GL_MAP1_TEXTURE_COORD_2:
1214 v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
1215 v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
1216 break;
1217 case GL_MAP1_TEXTURE_COORD_3:
1218 v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
1219 v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
1220 break;
1221 case GL_MAP1_TEXTURE_COORD_4:
1222 v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
1223 v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
1224 break;
1225 case GL_MAP1_VERTEX_3:
1226 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
1227 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
1228 break;
1229 case GL_MAP1_VERTEX_4:
1230 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
1231 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
1232 break;
1233 case GL_MAP2_COLOR_4:
1234 v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
1235 v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
1236 v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
1237 v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
1238 break;
1239 case GL_MAP2_INDEX:
1240 v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
1241 v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
1242 v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
1243 v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
1244 break;
1245 case GL_MAP2_NORMAL:
1246 v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
1247 v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
1248 v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
1249 v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
1250 break;
1251 case GL_MAP2_TEXTURE_COORD_1:
1252 v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
1253 v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
1254 v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
1255 v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
1256 break;
1257 case GL_MAP2_TEXTURE_COORD_2:
1258 v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
1259 v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
1260 v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
1261 v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
1262 break;
1263 case GL_MAP2_TEXTURE_COORD_3:
1264 v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
1265 v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
1266 v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
1267 v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
1268 break;
1269 case GL_MAP2_TEXTURE_COORD_4:
1270 v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
1271 v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
1272 v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
1273 v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
1274 break;
1275 case GL_MAP2_VERTEX_3:
1276 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
1277 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
1278 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
1279 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
1280 break;
1281 case GL_MAP2_VERTEX_4:
1282 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
1283 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
1284 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
1285 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
1286 break;
1287 default:
1288 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1289 }
1290 break;
1291 default:
1292 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
1293 }
1294 }
1295
1296
1297
1298 void
1299 _mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
1300 {
1301 GET_CURRENT_CONTEXT(ctx);
1302 ASSERT_OUTSIDE_BEGIN_END(ctx);
1303
1304 if (un<1) {
1305 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
1306 return;
1307 }
1308 FLUSH_VERTICES(ctx, _NEW_EVAL);
1309 ctx->Eval.MapGrid1un = un;
1310 ctx->Eval.MapGrid1u1 = u1;
1311 ctx->Eval.MapGrid1u2 = u2;
1312 ctx->Eval.MapGrid1du = (u2 - u1) / (GLfloat) un;
1313 }
1314
1315
1316 void
1317 _mesa_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
1318 {
1319 _mesa_MapGrid1f( un, u1, u2 );
1320 }
1321
1322
1323 void
1324 _mesa_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
1325 GLint vn, GLfloat v1, GLfloat v2 )
1326 {
1327 GET_CURRENT_CONTEXT(ctx);
1328 ASSERT_OUTSIDE_BEGIN_END(ctx);
1329
1330 if (un<1) {
1331 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
1332 return;
1333 }
1334 if (vn<1) {
1335 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
1336 return;
1337 }
1338
1339 FLUSH_VERTICES(ctx, _NEW_EVAL);
1340 ctx->Eval.MapGrid2un = un;
1341 ctx->Eval.MapGrid2u1 = u1;
1342 ctx->Eval.MapGrid2u2 = u2;
1343 ctx->Eval.MapGrid2du = (u2 - u1) / (GLfloat) un;
1344 ctx->Eval.MapGrid2vn = vn;
1345 ctx->Eval.MapGrid2v1 = v1;
1346 ctx->Eval.MapGrid2v2 = v2;
1347 ctx->Eval.MapGrid2dv = (v2 - v1) / (GLfloat) vn;
1348 }
1349
1350
1351 void
1352 _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
1353 GLint vn, GLdouble v1, GLdouble v2 )
1354 {
1355 _mesa_MapGrid2f( un, u1, u2, vn, v1, v2 );
1356 }
1357
1358
1359
1360