1 /* $Id: eval.c,v 1.23 2002/01/05 21:58:42 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
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:
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
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.
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).
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.
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.
60 GLuint
_mesa_evaluator_components( GLenum 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;
84 /* XXX need to check for the vertex program extension
85 if (!ctx->Extensions.NV_vertex_program)
89 if (target
>= GL_MAP1_VERTEX_ATTRIB0_4_NV
&&
90 target
<= GL_MAP1_VERTEX_ATTRIB15_4_NV
)
93 if (target
>= GL_MAP2_VERTEX_ATTRIB0_4_NV
&&
94 target
<= GL_MAP2_VERTEX_ATTRIB15_4_NV
)
102 * Return pointer to the gl_1d_map struct for the named target.
104 static struct gl_1d_map
*
105 get_1d_map( GLcontext
*ctx
, GLenum target
)
108 case GL_MAP1_VERTEX_3
:
109 return &ctx
->EvalMap
.Map1Vertex3
;
110 case GL_MAP1_VERTEX_4
:
111 return &ctx
->EvalMap
.Map1Vertex4
;
113 return &ctx
->EvalMap
.Map1Index
;
114 case GL_MAP1_COLOR_4
:
115 return &ctx
->EvalMap
.Map1Color4
;
117 return &ctx
->EvalMap
.Map1Normal
;
118 case GL_MAP1_TEXTURE_COORD_1
:
119 return &ctx
->EvalMap
.Map1Texture1
;
120 case GL_MAP1_TEXTURE_COORD_2
:
121 return &ctx
->EvalMap
.Map1Texture2
;
122 case GL_MAP1_TEXTURE_COORD_3
:
123 return &ctx
->EvalMap
.Map1Texture3
;
124 case GL_MAP1_TEXTURE_COORD_4
:
125 return &ctx
->EvalMap
.Map1Texture4
;
126 case GL_MAP1_VERTEX_ATTRIB0_4_NV
:
127 case GL_MAP1_VERTEX_ATTRIB1_4_NV
:
128 case GL_MAP1_VERTEX_ATTRIB2_4_NV
:
129 case GL_MAP1_VERTEX_ATTRIB3_4_NV
:
130 case GL_MAP1_VERTEX_ATTRIB4_4_NV
:
131 case GL_MAP1_VERTEX_ATTRIB5_4_NV
:
132 case GL_MAP1_VERTEX_ATTRIB6_4_NV
:
133 case GL_MAP1_VERTEX_ATTRIB7_4_NV
:
134 case GL_MAP1_VERTEX_ATTRIB8_4_NV
:
135 case GL_MAP1_VERTEX_ATTRIB9_4_NV
:
136 case GL_MAP1_VERTEX_ATTRIB10_4_NV
:
137 case GL_MAP1_VERTEX_ATTRIB11_4_NV
:
138 case GL_MAP1_VERTEX_ATTRIB12_4_NV
:
139 case GL_MAP1_VERTEX_ATTRIB13_4_NV
:
140 case GL_MAP1_VERTEX_ATTRIB14_4_NV
:
141 case GL_MAP1_VERTEX_ATTRIB15_4_NV
:
142 if (!ctx
->Extensions
.NV_vertex_program
)
144 return &ctx
->EvalMap
.Map1Attrib
[target
- GL_MAP1_VERTEX_ATTRIB0_4_NV
];
152 * Return pointer to the gl_2d_map struct for the named target.
154 static struct gl_2d_map
*
155 get_2d_map( GLcontext
*ctx
, GLenum target
)
158 case GL_MAP2_VERTEX_3
:
159 return &ctx
->EvalMap
.Map2Vertex3
;
160 case GL_MAP2_VERTEX_4
:
161 return &ctx
->EvalMap
.Map2Vertex4
;
163 return &ctx
->EvalMap
.Map2Index
;
164 case GL_MAP2_COLOR_4
:
165 return &ctx
->EvalMap
.Map2Color4
;
167 return &ctx
->EvalMap
.Map2Normal
;
168 case GL_MAP2_TEXTURE_COORD_1
:
169 return &ctx
->EvalMap
.Map2Texture1
;
170 case GL_MAP2_TEXTURE_COORD_2
:
171 return &ctx
->EvalMap
.Map2Texture2
;
172 case GL_MAP2_TEXTURE_COORD_3
:
173 return &ctx
->EvalMap
.Map2Texture3
;
174 case GL_MAP2_TEXTURE_COORD_4
:
175 return &ctx
->EvalMap
.Map2Texture4
;
176 case GL_MAP2_VERTEX_ATTRIB0_4_NV
:
177 case GL_MAP2_VERTEX_ATTRIB1_4_NV
:
178 case GL_MAP2_VERTEX_ATTRIB2_4_NV
:
179 case GL_MAP2_VERTEX_ATTRIB3_4_NV
:
180 case GL_MAP2_VERTEX_ATTRIB4_4_NV
:
181 case GL_MAP2_VERTEX_ATTRIB5_4_NV
:
182 case GL_MAP2_VERTEX_ATTRIB6_4_NV
:
183 case GL_MAP2_VERTEX_ATTRIB7_4_NV
:
184 case GL_MAP2_VERTEX_ATTRIB8_4_NV
:
185 case GL_MAP2_VERTEX_ATTRIB9_4_NV
:
186 case GL_MAP2_VERTEX_ATTRIB10_4_NV
:
187 case GL_MAP2_VERTEX_ATTRIB11_4_NV
:
188 case GL_MAP2_VERTEX_ATTRIB12_4_NV
:
189 case GL_MAP2_VERTEX_ATTRIB13_4_NV
:
190 case GL_MAP2_VERTEX_ATTRIB14_4_NV
:
191 case GL_MAP2_VERTEX_ATTRIB15_4_NV
:
192 if (!ctx
->Extensions
.NV_vertex_program
)
194 return &ctx
->EvalMap
.Map2Attrib
[target
- GL_MAP2_VERTEX_ATTRIB0_4_NV
];
201 /**********************************************************************/
202 /*** Copy and deallocate control points ***/
203 /**********************************************************************/
207 * Copy 1-parametric evaluator control points from user-specified
208 * memory space to a buffer of contiguous control points.
209 * Input: see glMap1f for details
210 * Return: pointer to buffer of contiguous control points or NULL if out
213 GLfloat
*_mesa_copy_map_points1f( GLenum target
, GLint ustride
, GLint uorder
,
214 const GLfloat
*points
)
217 GLint i
, k
, size
= _mesa_evaluator_components(target
);
219 if (!points
|| !size
)
222 buffer
= (GLfloat
*) MALLOC(uorder
* size
* sizeof(GLfloat
));
225 for (i
= 0, p
= buffer
; i
< uorder
; i
++, points
+= ustride
)
226 for (k
= 0; k
< size
; k
++)
235 * Same as above but convert doubles to floats.
237 GLfloat
*_mesa_copy_map_points1d( GLenum target
, GLint ustride
, GLint uorder
,
238 const GLdouble
*points
)
241 GLint i
, k
, size
= _mesa_evaluator_components(target
);
243 if (!points
|| !size
)
246 buffer
= (GLfloat
*) MALLOC(uorder
* size
* sizeof(GLfloat
));
249 for (i
= 0, p
= buffer
; i
< uorder
; i
++, points
+= ustride
)
250 for (k
= 0; k
< size
; k
++)
251 *p
++ = (GLfloat
) points
[k
];
259 * Copy 2-parametric evaluator control points from user-specified
260 * memory space to a buffer of contiguous control points.
261 * Additional memory is allocated to be used by the horner and
262 * de Casteljau evaluation schemes.
264 * Input: see glMap2f for details
265 * Return: pointer to buffer of contiguous control points or NULL if out
268 GLfloat
*_mesa_copy_map_points2f( GLenum target
,
269 GLint ustride
, GLint uorder
,
270 GLint vstride
, GLint vorder
,
271 const GLfloat
*points
)
274 GLint i
, j
, k
, size
, dsize
, hsize
;
277 size
= _mesa_evaluator_components(target
);
279 if (!points
|| size
==0) {
283 /* max(uorder, vorder) additional points are used in */
284 /* horner evaluation and uorder*vorder additional */
285 /* values are needed for de Casteljau */
286 dsize
= (uorder
== 2 && vorder
== 2)? 0 : uorder
*vorder
;
287 hsize
= (uorder
> vorder
? uorder
: vorder
)*size
;
290 buffer
= (GLfloat
*) MALLOC((uorder
*vorder
*size
+hsize
)*sizeof(GLfloat
));
292 buffer
= (GLfloat
*) MALLOC((uorder
*vorder
*size
+dsize
)*sizeof(GLfloat
));
294 /* compute the increment value for the u-loop */
295 uinc
= ustride
- vorder
*vstride
;
298 for (i
=0, p
=buffer
; i
<uorder
; i
++, points
+= uinc
)
299 for (j
=0; j
<vorder
; j
++, points
+= vstride
)
300 for (k
=0; k
<size
; k
++)
309 * Same as above but convert doubles to floats.
311 GLfloat
*_mesa_copy_map_points2d(GLenum target
,
312 GLint ustride
, GLint uorder
,
313 GLint vstride
, GLint vorder
,
314 const GLdouble
*points
)
317 GLint i
, j
, k
, size
, hsize
, dsize
;
320 size
= _mesa_evaluator_components(target
);
322 if (!points
|| size
==0) {
326 /* max(uorder, vorder) additional points are used in */
327 /* horner evaluation and uorder*vorder additional */
328 /* values are needed for de Casteljau */
329 dsize
= (uorder
== 2 && vorder
== 2)? 0 : uorder
*vorder
;
330 hsize
= (uorder
> vorder
? uorder
: vorder
)*size
;
333 buffer
= (GLfloat
*) MALLOC((uorder
*vorder
*size
+hsize
)*sizeof(GLfloat
));
335 buffer
= (GLfloat
*) MALLOC((uorder
*vorder
*size
+dsize
)*sizeof(GLfloat
));
337 /* compute the increment value for the u-loop */
338 uinc
= ustride
- vorder
*vstride
;
341 for (i
=0, p
=buffer
; i
<uorder
; i
++, points
+= uinc
)
342 for (j
=0; j
<vorder
; j
++, points
+= vstride
)
343 for (k
=0; k
<size
; k
++)
344 *p
++ = (GLfloat
) points
[k
];
352 /**********************************************************************/
353 /*** API entry points ***/
354 /**********************************************************************/
358 * This does the work of glMap1[fd].
361 map1(GLenum target
, GLfloat u1
, GLfloat u2
, GLint ustride
,
362 GLint uorder
, const GLvoid
*points
, GLenum type
)
364 GET_CURRENT_CONTEXT(ctx
);
367 struct gl_1d_map
*map
= NULL
;
369 ASSERT_OUTSIDE_BEGIN_END(ctx
);
370 ASSERT(type
== GL_FLOAT
|| type
== GL_DOUBLE
);
373 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap1(u1,u2)" );
376 if (uorder
< 1 || uorder
> MAX_EVAL_ORDER
) {
377 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap1(order)" );
381 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap1(points)" );
385 k
= _mesa_evaluator_components( target
);
387 _mesa_error( ctx
, GL_INVALID_ENUM
, "glMap1(target)" );
391 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap1(stride)" );
395 if (ctx
->Texture
.CurrentUnit
!= 0) {
396 /* See OpenGL 1.2.1 spec, section F.2.13 */
397 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glMap2(ACTIVE_TEXTURE != 0)" );
401 map
= get_1d_map(ctx
, target
);
403 _mesa_error( ctx
, GL_INVALID_ENUM
, "glMap1(target)" );
407 /* make copy of the control points */
408 if (type
== GL_FLOAT
)
409 pnts
= _mesa_copy_map_points1f(target
, ustride
, uorder
, (GLfloat
*) points
);
411 pnts
= _mesa_copy_map_points1d(target
, ustride
, uorder
, (GLdouble
*) points
);
414 FLUSH_VERTICES(ctx
, _NEW_EVAL
);
418 map
->du
= 1.0F
/ (u2
- u1
);
427 _mesa_Map1f( GLenum target
, GLfloat u1
, GLfloat u2
, GLint stride
,
428 GLint order
, const GLfloat
*points
)
430 map1(target
, u1
, u2
, stride
, order
, points
, GL_FLOAT
);
435 _mesa_Map1d( GLenum target
, GLdouble u1
, GLdouble u2
, GLint stride
,
436 GLint order
, const GLdouble
*points
)
438 map1(target
, (GLfloat
) u1
, (GLfloat
) u2
, stride
, order
, points
, GL_DOUBLE
);
443 map2( GLenum target
, GLfloat u1
, GLfloat u2
, GLint ustride
, GLint uorder
,
444 GLfloat v1
, GLfloat v2
, GLint vstride
, GLint vorder
,
445 const GLvoid
*points
, GLenum type
)
447 GET_CURRENT_CONTEXT(ctx
);
450 struct gl_2d_map
*map
= NULL
;
452 ASSERT_OUTSIDE_BEGIN_END(ctx
);
453 ASSERT(type
== GL_FLOAT
|| type
== GL_DOUBLE
);
456 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap2(u1,u2)" );
461 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap2(v1,v2)" );
465 if (uorder
<1 || uorder
>MAX_EVAL_ORDER
) {
466 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap2(uorder)" );
470 if (vorder
<1 || vorder
>MAX_EVAL_ORDER
) {
471 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap2(vorder)" );
475 k
= _mesa_evaluator_components( target
);
477 _mesa_error( ctx
, GL_INVALID_ENUM
, "glMap2(target)" );
481 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap2(ustride)" );
485 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMap2(vstride)" );
489 if (ctx
->Texture
.CurrentUnit
!= 0) {
490 /* See OpenGL 1.2.1 spec, section F.2.13 */
491 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glMap2(ACTIVE_TEXTURE != 0)" );
495 map
= get_2d_map(ctx
, target
);
497 _mesa_error( ctx
, GL_INVALID_ENUM
, "glMap2(target)" );
501 /* make copy of the control points */
502 if (type
== GL_FLOAT
)
503 pnts
= _mesa_copy_map_points2f(target
, ustride
, uorder
,
504 vstride
, vorder
, (GLfloat
*) points
);
506 pnts
= _mesa_copy_map_points2d(target
, ustride
, uorder
,
507 vstride
, vorder
, (GLdouble
*) points
);
510 FLUSH_VERTICES(ctx
, _NEW_EVAL
);
511 map
->Uorder
= uorder
;
514 map
->du
= 1.0F
/ (u2
- u1
);
515 map
->Vorder
= vorder
;
518 map
->dv
= 1.0F
/ (v2
- v1
);
526 _mesa_Map2f( GLenum target
,
527 GLfloat u1
, GLfloat u2
, GLint ustride
, GLint uorder
,
528 GLfloat v1
, GLfloat v2
, GLint vstride
, GLint vorder
,
529 const GLfloat
*points
)
531 map2(target
, u1
, u2
, ustride
, uorder
, v1
, v2
, vstride
, vorder
,
537 _mesa_Map2d( GLenum target
,
538 GLdouble u1
, GLdouble u2
, GLint ustride
, GLint uorder
,
539 GLdouble v1
, GLdouble v2
, GLint vstride
, GLint vorder
,
540 const GLdouble
*points
)
542 map2(target
, (GLfloat
) u1
, (GLfloat
) u2
, ustride
, uorder
,
543 (GLfloat
) v1
, (GLfloat
) v2
, vstride
, vorder
, points
, GL_DOUBLE
);
549 _mesa_GetMapdv( GLenum target
, GLenum query
, GLdouble
*v
)
551 GET_CURRENT_CONTEXT(ctx
);
552 struct gl_1d_map
*map1d
;
553 struct gl_2d_map
*map2d
;
558 ASSERT_OUTSIDE_BEGIN_END(ctx
);
560 comps
= _mesa_evaluator_components(target
);
562 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetMapdv(target)" );
566 map1d
= get_1d_map(ctx
, target
);
567 map2d
= get_2d_map(ctx
, target
);
568 ASSERT(map1d
|| map2d
);
573 data
= map1d
->Points
;
574 n
= map1d
->Order
* comps
;
577 data
= map2d
->Points
;
578 n
= map2d
->Uorder
* map2d
->Vorder
* comps
;
588 v
[0] = (GLdouble
) map1d
->Order
;
591 v
[0] = (GLdouble
) map2d
->Uorder
;
592 v
[1] = (GLdouble
) map2d
->Vorder
;
597 v
[0] = (GLdouble
) map1d
->u1
;
598 v
[1] = (GLdouble
) map1d
->u2
;
601 v
[0] = (GLdouble
) map2d
->u1
;
602 v
[1] = (GLdouble
) map2d
->u2
;
603 v
[2] = (GLdouble
) map2d
->v1
;
604 v
[3] = (GLdouble
) map2d
->v2
;
608 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetMapdv(query)" );
614 _mesa_GetMapfv( GLenum target
, GLenum query
, GLfloat
*v
)
616 GET_CURRENT_CONTEXT(ctx
);
617 struct gl_1d_map
*map1d
;
618 struct gl_2d_map
*map2d
;
623 ASSERT_OUTSIDE_BEGIN_END(ctx
);
625 comps
= _mesa_evaluator_components(target
);
627 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetMapfv(target)" );
631 map1d
= get_1d_map(ctx
, target
);
632 map2d
= get_2d_map(ctx
, target
);
633 ASSERT(map1d
|| map2d
);
638 data
= map1d
->Points
;
639 n
= map1d
->Order
* comps
;
642 data
= map2d
->Points
;
643 n
= map2d
->Uorder
* map2d
->Vorder
* comps
;
653 v
[0] = (GLfloat
) map1d
->Order
;
656 v
[0] = (GLfloat
) map2d
->Uorder
;
657 v
[1] = (GLfloat
) map2d
->Vorder
;
673 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetMapfv(query)" );
679 _mesa_GetMapiv( GLenum target
, GLenum query
, GLint
*v
)
681 GET_CURRENT_CONTEXT(ctx
);
682 struct gl_1d_map
*map1d
;
683 struct gl_2d_map
*map2d
;
688 ASSERT_OUTSIDE_BEGIN_END(ctx
);
690 comps
= _mesa_evaluator_components(target
);
692 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetMapiv(target)" );
696 map1d
= get_1d_map(ctx
, target
);
697 map2d
= get_2d_map(ctx
, target
);
698 ASSERT(map1d
|| map2d
);
703 data
= map1d
->Points
;
704 n
= map1d
->Order
* comps
;
707 data
= map2d
->Points
;
708 n
= map2d
->Uorder
* map2d
->Vorder
* comps
;
712 v
[i
] = ROUNDF(data
[i
]);
721 v
[0] = map2d
->Uorder
;
722 v
[1] = map2d
->Vorder
;
727 v
[0] = ROUNDF(map1d
->u1
);
728 v
[1] = ROUNDF(map1d
->u2
);
731 v
[0] = ROUNDF(map2d
->u1
);
732 v
[1] = ROUNDF(map2d
->u2
);
733 v
[2] = ROUNDF(map2d
->v1
);
734 v
[3] = ROUNDF(map2d
->v2
);
738 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetMapiv(query)" );
745 _mesa_MapGrid1f( GLint un
, GLfloat u1
, GLfloat u2
)
747 GET_CURRENT_CONTEXT(ctx
);
748 ASSERT_OUTSIDE_BEGIN_END(ctx
);
751 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMapGrid1f" );
754 FLUSH_VERTICES(ctx
, _NEW_EVAL
);
755 ctx
->Eval
.MapGrid1un
= un
;
756 ctx
->Eval
.MapGrid1u1
= u1
;
757 ctx
->Eval
.MapGrid1u2
= u2
;
758 ctx
->Eval
.MapGrid1du
= (u2
- u1
) / (GLfloat
) un
;
763 _mesa_MapGrid1d( GLint un
, GLdouble u1
, GLdouble u2
)
765 _mesa_MapGrid1f( un
, (GLfloat
) u1
, (GLfloat
) u2
);
770 _mesa_MapGrid2f( GLint un
, GLfloat u1
, GLfloat u2
,
771 GLint vn
, GLfloat v1
, GLfloat v2
)
773 GET_CURRENT_CONTEXT(ctx
);
774 ASSERT_OUTSIDE_BEGIN_END(ctx
);
777 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMapGrid2f(un)" );
781 _mesa_error( ctx
, GL_INVALID_VALUE
, "glMapGrid2f(vn)" );
785 FLUSH_VERTICES(ctx
, _NEW_EVAL
);
786 ctx
->Eval
.MapGrid2un
= un
;
787 ctx
->Eval
.MapGrid2u1
= u1
;
788 ctx
->Eval
.MapGrid2u2
= u2
;
789 ctx
->Eval
.MapGrid2du
= (u2
- u1
) / (GLfloat
) un
;
790 ctx
->Eval
.MapGrid2vn
= vn
;
791 ctx
->Eval
.MapGrid2v1
= v1
;
792 ctx
->Eval
.MapGrid2v2
= v2
;
793 ctx
->Eval
.MapGrid2dv
= (v2
- v1
) / (GLfloat
) vn
;
798 _mesa_MapGrid2d( GLint un
, GLdouble u1
, GLdouble u2
,
799 GLint vn
, GLdouble v1
, GLdouble v2
)
801 _mesa_MapGrid2f( un
, (GLfloat
) u1
, (GLfloat
) u2
,
802 vn
, (GLfloat
) v1
, (GLfloat
) v2
);