1 /* $Id: eval.c,v 1.1 1999/08/19 00:55:41 jtg Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999 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.
32 * eval.c was written by
33 * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
34 * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
36 * My original implementation of evaluators was simplistic and didn't
37 * compute surface normal vectors properly. Bernd and Volker applied
38 * used more sophisticated methods to get better results.
59 #include "GL/xf86glx.h"
64 static GLfloat inv_tab
[MAX_EVAL_ORDER
];
67 * Do one-time initialization for evaluators.
69 void gl_init_eval( void )
71 static int init_flag
= 0;
74 /* Compute a table of nCr (combination) values used by the
75 * Bernstein polynomial generator.
78 /* KW: precompute 1/x for useful x.
82 for (i
= 1 ; i
< MAX_EVAL_ORDER
; i
++)
92 * Horner scheme for Bezier curves
94 * Bezier curves can be computed via a Horner scheme.
95 * Horner is numerically less stable than the de Casteljau
96 * algorithm, but it is faster. For curves of degree n
97 * the complexity of Horner is O(n) and de Casteljau is O(n^2).
98 * Since stability is not important for displaying curve
99 * points I decided to use the Horner scheme.
101 * A cubic Bezier curve with control points b0, b1, b2, b3 can be
104 * (([3] [3] ) [3] ) [3]
105 * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
108 * where s=1-t and the binomial coefficients [i]. These can
109 * be computed iteratively using the identity:
112 * [i] = (n-i+1)/i * [i-1] and [0] = 1
117 horner_bezier_curve(const GLfloat
*cp
, GLfloat
*out
, GLfloat t
,
118 GLuint dim
, GLuint order
)
121 GLuint i
, k
, bincoeff
;
129 out
[k
] = s
*cp
[k
] + bincoeff
*t
*cp
[dim
+k
];
131 for(i
=2, cp
+=2*dim
, powert
=t
*t
; i
<order
; i
++, powert
*=t
, cp
+=dim
)
134 bincoeff
*= inv_tab
[i
];
137 out
[k
] = s
*out
[k
] + bincoeff
*powert
*cp
[k
];
140 else /* order=1 -> constant curve */
148 * Tensor product Bezier surfaces
150 * Again the Horner scheme is used to compute a point on a
151 * TP Bezier surface. First a control polygon for a curve
152 * on the surface in one parameter direction is computed,
153 * then the point on the curve for the other parameter
154 * direction is evaluated.
156 * To store the curve control polygon additional storage
157 * for max(uorder,vorder) points is needed in the
162 horner_bezier_surf(GLfloat
*cn
, GLfloat
*out
, GLfloat u
, GLfloat v
,
163 GLuint dim
, GLuint uorder
, GLuint vorder
)
165 GLfloat
*cp
= cn
+ uorder
*vorder
*dim
;
166 GLuint i
, uinc
= vorder
*dim
;
173 GLuint j
, k
, bincoeff
;
175 /* Compute the control polygon for the surface-curve in u-direction */
176 for(j
=0; j
<vorder
; j
++)
178 GLfloat
*ucp
= &cn
[j
*dim
];
180 /* Each control point is the point for parameter u on a */
181 /* curve defined by the control polygons in u-direction */
186 cp
[j
*dim
+k
] = s
*ucp
[k
] + bincoeff
*u
*ucp
[uinc
+k
];
188 for(i
=2, ucp
+=2*uinc
, poweru
=u
*u
; i
<uorder
;
189 i
++, poweru
*=u
, ucp
+=uinc
)
191 bincoeff
*= uorder
-i
;
192 bincoeff
*= inv_tab
[i
];
195 cp
[j
*dim
+k
] = s
*cp
[j
*dim
+k
] + bincoeff
*poweru
*ucp
[k
];
199 /* Evaluate curve point in v */
200 horner_bezier_curve(cp
, out
, v
, dim
, vorder
);
202 else /* uorder=1 -> cn defines a curve in v */
203 horner_bezier_curve(cn
, out
, v
, dim
, vorder
);
205 else /* vorder <= uorder */
211 /* Compute the control polygon for the surface-curve in u-direction */
212 for(i
=0; i
<uorder
; i
++, cn
+= uinc
)
214 /* For constant i all cn[i][j] (j=0..vorder) are located */
215 /* on consecutive memory locations, so we can use */
216 /* horner_bezier_curve to compute the control points */
218 horner_bezier_curve(cn
, &cp
[i
*dim
], v
, dim
, vorder
);
221 /* Evaluate curve point in u */
222 horner_bezier_curve(cp
, out
, u
, dim
, uorder
);
224 else /* vorder=1 -> cn defines a curve in u */
225 horner_bezier_curve(cn
, out
, u
, dim
, uorder
);
230 * The direct de Casteljau algorithm is used when a point on the
231 * surface and the tangent directions spanning the tangent plane
232 * should be computed (this is needed to compute normals to the
233 * surface). In this case the de Casteljau algorithm approach is
234 * nicer because a point and the partial derivatives can be computed
235 * at the same time. To get the correct tangent length du and dv
236 * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1.
237 * Since only the directions are needed, this scaling step is omitted.
239 * De Casteljau needs additional storage for uorder*vorder
240 * values in the control net cn.
244 de_casteljau_surf(GLfloat
*cn
, GLfloat
*out
, GLfloat
*du
, GLfloat
*dv
,
245 GLfloat u
, GLfloat v
, GLuint dim
,
246 GLuint uorder
, GLuint vorder
)
248 GLfloat
*dcn
= cn
+ uorder
*vorder
*dim
;
249 GLfloat us
= 1.0-u
, vs
= 1.0-v
;
251 GLuint minorder
= uorder
< vorder
? uorder
: vorder
;
252 GLuint uinc
= vorder
*dim
;
253 GLuint dcuinc
= vorder
;
255 /* Each component is evaluated separately to save buffer space */
256 /* This does not drasticaly decrease the performance of the */
257 /* algorithm. If additional storage for (uorder-1)*(vorder-1) */
258 /* points would be available, the components could be accessed */
259 /* in the innermost loop which could lead to less cache misses. */
261 #define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)]
262 #define DCN(I, J) dcn[(I)*dcuinc+(J)]
269 /* Derivative direction in u */
270 du
[k
] = vs
*(CN(1,0,k
) - CN(0,0,k
)) +
271 v
*(CN(1,1,k
) - CN(0,1,k
));
273 /* Derivative direction in v */
274 dv
[k
] = us
*(CN(0,1,k
) - CN(0,0,k
)) +
275 u
*(CN(1,1,k
) - CN(1,0,k
));
277 /* bilinear de Casteljau step */
278 out
[k
] = us
*(vs
*CN(0,0,k
) + v
*CN(0,1,k
)) +
279 u
*(vs
*CN(1,0,k
) + v
*CN(1,1,k
));
282 else if(minorder
== uorder
)
286 /* bilinear de Casteljau step */
287 DCN(1,0) = CN(1,0,k
) - CN(0,0,k
);
288 DCN(0,0) = us
*CN(0,0,k
) + u
*CN(1,0,k
);
290 for(j
=0; j
<vorder
-1; j
++)
292 /* for the derivative in u */
293 DCN(1,j
+1) = CN(1,j
+1,k
) - CN(0,j
+1,k
);
294 DCN(1,j
) = vs
*DCN(1,j
) + v
*DCN(1,j
+1);
296 /* for the `point' */
297 DCN(0,j
+1) = us
*CN(0,j
+1,k
) + u
*CN(1,j
+1,k
);
298 DCN(0,j
) = vs
*DCN(0,j
) + v
*DCN(0,j
+1);
301 /* remaining linear de Casteljau steps until the second last step */
302 for(h
=minorder
; h
<vorder
-1; h
++)
303 for(j
=0; j
<vorder
-h
; j
++)
305 /* for the derivative in u */
306 DCN(1,j
) = vs
*DCN(1,j
) + v
*DCN(1,j
+1);
308 /* for the `point' */
309 DCN(0,j
) = vs
*DCN(0,j
) + v
*DCN(0,j
+1);
312 /* derivative direction in v */
313 dv
[k
] = DCN(0,1) - DCN(0,0);
315 /* derivative direction in u */
316 du
[k
] = vs
*DCN(1,0) + v
*DCN(1,1);
318 /* last linear de Casteljau step */
319 out
[k
] = vs
*DCN(0,0) + v
*DCN(0,1);
322 else /* minorder == vorder */
326 /* bilinear de Casteljau step */
327 DCN(0,1) = CN(0,1,k
) - CN(0,0,k
);
328 DCN(0,0) = vs
*CN(0,0,k
) + v
*CN(0,1,k
);
329 for(i
=0; i
<uorder
-1; i
++)
331 /* for the derivative in v */
332 DCN(i
+1,1) = CN(i
+1,1,k
) - CN(i
+1,0,k
);
333 DCN(i
,1) = us
*DCN(i
,1) + u
*DCN(i
+1,1);
335 /* for the `point' */
336 DCN(i
+1,0) = vs
*CN(i
+1,0,k
) + v
*CN(i
+1,1,k
);
337 DCN(i
,0) = us
*DCN(i
,0) + u
*DCN(i
+1,0);
340 /* remaining linear de Casteljau steps until the second last step */
341 for(h
=minorder
; h
<uorder
-1; h
++)
342 for(i
=0; i
<uorder
-h
; i
++)
344 /* for the derivative in v */
345 DCN(i
,1) = us
*DCN(i
,1) + u
*DCN(i
+1,1);
347 /* for the `point' */
348 DCN(i
,0) = us
*DCN(i
,0) + u
*DCN(i
+1,0);
351 /* derivative direction in u */
352 du
[k
] = DCN(1,0) - DCN(0,0);
354 /* derivative direction in v */
355 dv
[k
] = us
*DCN(0,1) + u
*DCN(1,1);
357 /* last linear de Casteljau step */
358 out
[k
] = us
*DCN(0,0) + u
*DCN(1,0);
362 else if(uorder
== vorder
)
366 /* first bilinear de Casteljau step */
367 for(i
=0; i
<uorder
-1; i
++)
369 DCN(i
,0) = us
*CN(i
,0,k
) + u
*CN(i
+1,0,k
);
370 for(j
=0; j
<vorder
-1; j
++)
372 DCN(i
,j
+1) = us
*CN(i
,j
+1,k
) + u
*CN(i
+1,j
+1,k
);
373 DCN(i
,j
) = vs
*DCN(i
,j
) + v
*DCN(i
,j
+1);
377 /* remaining bilinear de Casteljau steps until the second last step */
378 for(h
=2; h
<minorder
-1; h
++)
379 for(i
=0; i
<uorder
-h
; i
++)
381 DCN(i
,0) = us
*DCN(i
,0) + u
*DCN(i
+1,0);
382 for(j
=0; j
<vorder
-h
; j
++)
384 DCN(i
,j
+1) = us
*DCN(i
,j
+1) + u
*DCN(i
+1,j
+1);
385 DCN(i
,j
) = vs
*DCN(i
,j
) + v
*DCN(i
,j
+1);
389 /* derivative direction in u */
390 du
[k
] = vs
*(DCN(1,0) - DCN(0,0)) +
391 v
*(DCN(1,1) - DCN(0,1));
393 /* derivative direction in v */
394 dv
[k
] = us
*(DCN(0,1) - DCN(0,0)) +
395 u
*(DCN(1,1) - DCN(1,0));
397 /* last bilinear de Casteljau step */
398 out
[k
] = us
*(vs
*DCN(0,0) + v
*DCN(0,1)) +
399 u
*(vs
*DCN(1,0) + v
*DCN(1,1));
402 else if(minorder
== uorder
)
406 /* first bilinear de Casteljau step */
407 for(i
=0; i
<uorder
-1; i
++)
409 DCN(i
,0) = us
*CN(i
,0,k
) + u
*CN(i
+1,0,k
);
410 for(j
=0; j
<vorder
-1; j
++)
412 DCN(i
,j
+1) = us
*CN(i
,j
+1,k
) + u
*CN(i
+1,j
+1,k
);
413 DCN(i
,j
) = vs
*DCN(i
,j
) + v
*DCN(i
,j
+1);
417 /* remaining bilinear de Casteljau steps until the second last step */
418 for(h
=2; h
<minorder
-1; h
++)
419 for(i
=0; i
<uorder
-h
; i
++)
421 DCN(i
,0) = us
*DCN(i
,0) + u
*DCN(i
+1,0);
422 for(j
=0; j
<vorder
-h
; j
++)
424 DCN(i
,j
+1) = us
*DCN(i
,j
+1) + u
*DCN(i
+1,j
+1);
425 DCN(i
,j
) = vs
*DCN(i
,j
) + v
*DCN(i
,j
+1);
429 /* last bilinear de Casteljau step */
430 DCN(2,0) = DCN(1,0) - DCN(0,0);
431 DCN(0,0) = us
*DCN(0,0) + u
*DCN(1,0);
432 for(j
=0; j
<vorder
-1; j
++)
434 /* for the derivative in u */
435 DCN(2,j
+1) = DCN(1,j
+1) - DCN(0,j
+1);
436 DCN(2,j
) = vs
*DCN(2,j
) + v
*DCN(2,j
+1);
438 /* for the `point' */
439 DCN(0,j
+1) = us
*DCN(0,j
+1 ) + u
*DCN(1,j
+1);
440 DCN(0,j
) = vs
*DCN(0,j
) + v
*DCN(0,j
+1);
443 /* remaining linear de Casteljau steps until the second last step */
444 for(h
=minorder
; h
<vorder
-1; h
++)
445 for(j
=0; j
<vorder
-h
; j
++)
447 /* for the derivative in u */
448 DCN(2,j
) = vs
*DCN(2,j
) + v
*DCN(2,j
+1);
450 /* for the `point' */
451 DCN(0,j
) = vs
*DCN(0,j
) + v
*DCN(0,j
+1);
454 /* derivative direction in v */
455 dv
[k
] = DCN(0,1) - DCN(0,0);
457 /* derivative direction in u */
458 du
[k
] = vs
*DCN(2,0) + v
*DCN(2,1);
460 /* last linear de Casteljau step */
461 out
[k
] = vs
*DCN(0,0) + v
*DCN(0,1);
464 else /* minorder == vorder */
468 /* first bilinear de Casteljau step */
469 for(i
=0; i
<uorder
-1; i
++)
471 DCN(i
,0) = us
*CN(i
,0,k
) + u
*CN(i
+1,0,k
);
472 for(j
=0; j
<vorder
-1; j
++)
474 DCN(i
,j
+1) = us
*CN(i
,j
+1,k
) + u
*CN(i
+1,j
+1,k
);
475 DCN(i
,j
) = vs
*DCN(i
,j
) + v
*DCN(i
,j
+1);
479 /* remaining bilinear de Casteljau steps until the second last step */
480 for(h
=2; h
<minorder
-1; h
++)
481 for(i
=0; i
<uorder
-h
; i
++)
483 DCN(i
,0) = us
*DCN(i
,0) + u
*DCN(i
+1,0);
484 for(j
=0; j
<vorder
-h
; j
++)
486 DCN(i
,j
+1) = us
*DCN(i
,j
+1) + u
*DCN(i
+1,j
+1);
487 DCN(i
,j
) = vs
*DCN(i
,j
) + v
*DCN(i
,j
+1);
491 /* last bilinear de Casteljau step */
492 DCN(0,2) = DCN(0,1) - DCN(0,0);
493 DCN(0,0) = vs
*DCN(0,0) + v
*DCN(0,1);
494 for(i
=0; i
<uorder
-1; i
++)
496 /* for the derivative in v */
497 DCN(i
+1,2) = DCN(i
+1,1) - DCN(i
+1,0);
498 DCN(i
,2) = us
*DCN(i
,2) + u
*DCN(i
+1,2);
500 /* for the `point' */
501 DCN(i
+1,0) = vs
*DCN(i
+1,0) + v
*DCN(i
+1,1);
502 DCN(i
,0) = us
*DCN(i
,0) + u
*DCN(i
+1,0);
505 /* remaining linear de Casteljau steps until the second last step */
506 for(h
=minorder
; h
<uorder
-1; h
++)
507 for(i
=0; i
<uorder
-h
; i
++)
509 /* for the derivative in v */
510 DCN(i
,2) = us
*DCN(i
,2) + u
*DCN(i
+1,2);
512 /* for the `point' */
513 DCN(i
,0) = us
*DCN(i
,0) + u
*DCN(i
+1,0);
516 /* derivative direction in u */
517 du
[k
] = DCN(1,0) - DCN(0,0);
519 /* derivative direction in v */
520 dv
[k
] = us
*DCN(0,2) + u
*DCN(1,2);
522 /* last linear de Casteljau step */
523 out
[k
] = us
*DCN(0,0) + u
*DCN(1,0);
531 * Return the number of components per control point for any type of
532 * evaluator. Return 0 if bad target.
535 static GLint
components( GLenum target
)
538 case GL_MAP1_VERTEX_3
: return 3;
539 case GL_MAP1_VERTEX_4
: return 4;
540 case GL_MAP1_INDEX
: return 1;
541 case GL_MAP1_COLOR_4
: return 4;
542 case GL_MAP1_NORMAL
: return 3;
543 case GL_MAP1_TEXTURE_COORD_1
: return 1;
544 case GL_MAP1_TEXTURE_COORD_2
: return 2;
545 case GL_MAP1_TEXTURE_COORD_3
: return 3;
546 case GL_MAP1_TEXTURE_COORD_4
: return 4;
547 case GL_MAP2_VERTEX_3
: return 3;
548 case GL_MAP2_VERTEX_4
: return 4;
549 case GL_MAP2_INDEX
: return 1;
550 case GL_MAP2_COLOR_4
: return 4;
551 case GL_MAP2_NORMAL
: return 3;
552 case GL_MAP2_TEXTURE_COORD_1
: return 1;
553 case GL_MAP2_TEXTURE_COORD_2
: return 2;
554 case GL_MAP2_TEXTURE_COORD_3
: return 3;
555 case GL_MAP2_TEXTURE_COORD_4
: return 4;
561 /**********************************************************************/
562 /*** Copy and deallocate control points ***/
563 /**********************************************************************/
567 * Copy 1-parametric evaluator control points from user-specified
568 * memory space to a buffer of contiguous control points.
569 * Input: see glMap1f for details
570 * Return: pointer to buffer of contiguous control points or NULL if out
573 GLfloat
*gl_copy_map_points1f( GLenum target
,
574 GLint ustride
, GLint uorder
,
575 const GLfloat
*points
)
578 GLint i
, k
, size
= components(target
);
580 if (!points
|| size
==0) {
584 buffer
= (GLfloat
*) malloc(uorder
* size
* sizeof(GLfloat
));
587 for(i
=0, p
=buffer
; i
<uorder
; i
++, points
+=ustride
)
588 for(k
=0; k
<size
; k
++)
597 * Same as above but convert doubles to floats.
599 GLfloat
*gl_copy_map_points1d( GLenum target
,
600 GLint ustride
, GLint uorder
,
601 const GLdouble
*points
)
604 GLint i
, k
, size
= components(target
);
606 if (!points
|| size
==0) {
610 buffer
= (GLfloat
*) malloc(uorder
* size
* sizeof(GLfloat
));
613 for(i
=0, p
=buffer
; i
<uorder
; i
++, points
+=ustride
)
614 for(k
=0; k
<size
; k
++)
615 *p
++ = (GLfloat
) points
[k
];
623 * Copy 2-parametric evaluator control points from user-specified
624 * memory space to a buffer of contiguous control points.
625 * Additional memory is allocated to be used by the horner and
626 * de Casteljau evaluation schemes.
628 * Input: see glMap2f for details
629 * Return: pointer to buffer of contiguous control points or NULL if out
632 GLfloat
*gl_copy_map_points2f( GLenum target
,
633 GLint ustride
, GLint uorder
,
634 GLint vstride
, GLint vorder
,
635 const GLfloat
*points
)
638 GLint i
, j
, k
, size
, dsize
, hsize
;
641 size
= components(target
);
643 if (!points
|| size
==0) {
647 /* max(uorder, vorder) additional points are used in */
648 /* horner evaluation and uorder*vorder additional */
649 /* values are needed for de Casteljau */
650 dsize
= (uorder
== 2 && vorder
== 2)? 0 : uorder
*vorder
;
651 hsize
= (uorder
> vorder
? uorder
: vorder
)*size
;
654 buffer
= (GLfloat
*) malloc((uorder
*vorder
*size
+hsize
)*sizeof(GLfloat
));
656 buffer
= (GLfloat
*) malloc((uorder
*vorder
*size
+dsize
)*sizeof(GLfloat
));
658 /* compute the increment value for the u-loop */
659 uinc
= ustride
- vorder
*vstride
;
662 for (i
=0, p
=buffer
; i
<uorder
; i
++, points
+= uinc
)
663 for (j
=0; j
<vorder
; j
++, points
+= vstride
)
664 for (k
=0; k
<size
; k
++)
673 * Same as above but convert doubles to floats.
675 GLfloat
*gl_copy_map_points2d(GLenum target
,
676 GLint ustride
, GLint uorder
,
677 GLint vstride
, GLint vorder
,
678 const GLdouble
*points
)
681 GLint i
, j
, k
, size
, hsize
, dsize
;
684 size
= components(target
);
686 if (!points
|| size
==0) {
690 /* max(uorder, vorder) additional points are used in */
691 /* horner evaluation and uorder*vorder additional */
692 /* values are needed for de Casteljau */
693 dsize
= (uorder
== 2 && vorder
== 2)? 0 : uorder
*vorder
;
694 hsize
= (uorder
> vorder
? uorder
: vorder
)*size
;
697 buffer
= (GLfloat
*) malloc((uorder
*vorder
*size
+hsize
)*sizeof(GLfloat
));
699 buffer
= (GLfloat
*) malloc((uorder
*vorder
*size
+dsize
)*sizeof(GLfloat
));
701 /* compute the increment value for the u-loop */
702 uinc
= ustride
- vorder
*vstride
;
705 for (i
=0, p
=buffer
; i
<uorder
; i
++, points
+= uinc
)
706 for (j
=0; j
<vorder
; j
++, points
+= vstride
)
707 for (k
=0; k
<size
; k
++)
708 *p
++ = (GLfloat
) points
[k
];
715 * This function is called by the display list deallocator function to
716 * specify that a given set of control points are no longer needed.
718 void gl_free_control_points( GLcontext
* ctx
, GLenum target
, GLfloat
*data
)
720 struct gl_1d_map
*map1
= NULL
;
721 struct gl_2d_map
*map2
= NULL
;
724 case GL_MAP1_VERTEX_3
:
725 map1
= &ctx
->EvalMap
.Map1Vertex3
;
727 case GL_MAP1_VERTEX_4
:
728 map1
= &ctx
->EvalMap
.Map1Vertex4
;
731 map1
= &ctx
->EvalMap
.Map1Index
;
733 case GL_MAP1_COLOR_4
:
734 map1
= &ctx
->EvalMap
.Map1Color4
;
737 map1
= &ctx
->EvalMap
.Map1Normal
;
739 case GL_MAP1_TEXTURE_COORD_1
:
740 map1
= &ctx
->EvalMap
.Map1Texture1
;
742 case GL_MAP1_TEXTURE_COORD_2
:
743 map1
= &ctx
->EvalMap
.Map1Texture2
;
745 case GL_MAP1_TEXTURE_COORD_3
:
746 map1
= &ctx
->EvalMap
.Map1Texture3
;
748 case GL_MAP1_TEXTURE_COORD_4
:
749 map1
= &ctx
->EvalMap
.Map1Texture4
;
751 case GL_MAP2_VERTEX_3
:
752 map2
= &ctx
->EvalMap
.Map2Vertex3
;
754 case GL_MAP2_VERTEX_4
:
755 map2
= &ctx
->EvalMap
.Map2Vertex4
;
758 map2
= &ctx
->EvalMap
.Map2Index
;
760 case GL_MAP2_COLOR_4
:
761 map2
= &ctx
->EvalMap
.Map2Color4
;
764 map2
= &ctx
->EvalMap
.Map2Normal
;
766 case GL_MAP2_TEXTURE_COORD_1
:
767 map2
= &ctx
->EvalMap
.Map2Texture1
;
769 case GL_MAP2_TEXTURE_COORD_2
:
770 map2
= &ctx
->EvalMap
.Map2Texture2
;
772 case GL_MAP2_TEXTURE_COORD_3
:
773 map2
= &ctx
->EvalMap
.Map2Texture3
;
775 case GL_MAP2_TEXTURE_COORD_4
:
776 map2
= &ctx
->EvalMap
.Map2Texture4
;
779 gl_error( ctx
, GL_INVALID_ENUM
, "gl_free_control_points" );
784 if (data
==map1
->Points
) {
785 /* The control points in the display list are currently */
786 /* being used so we can mark them as discard-able. */
787 map1
->Retain
= GL_FALSE
;
790 /* The control points in the display list are not currently */
796 if (data
==map2
->Points
) {
797 /* The control points in the display list are currently */
798 /* being used so we can mark them as discard-able. */
799 map2
->Retain
= GL_FALSE
;
802 /* The control points in the display list are not currently */
812 /**********************************************************************/
813 /*** API entry points ***/
814 /**********************************************************************/
818 * Note that the array of control points must be 'unpacked' at this time.
819 * Input: retain - if TRUE, this control point data is also in a display
820 * list and can't be freed until the list is freed.
822 void gl_Map1f( GLcontext
* ctx
, GLenum target
,
823 GLfloat u1
, GLfloat u2
, GLint stride
,
824 GLint order
, const GLfloat
*points
, GLboolean retain
)
829 gl_error( ctx
, GL_OUT_OF_MEMORY
, "glMap1f" );
833 /* may be a new stride after copying control points */
834 stride
= components( target
);
836 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glMap1");
839 gl_error( ctx
, GL_INVALID_VALUE
, "glMap1(u1,u2)" );
843 if (order
<1 || order
>MAX_EVAL_ORDER
) {
844 gl_error( ctx
, GL_INVALID_VALUE
, "glMap1(order)" );
848 k
= components( target
);
850 gl_error( ctx
, GL_INVALID_ENUM
, "glMap1(target)" );
854 gl_error( ctx
, GL_INVALID_VALUE
, "glMap1(stride)" );
859 case GL_MAP1_VERTEX_3
:
860 ctx
->EvalMap
.Map1Vertex3
.Order
= order
;
861 ctx
->EvalMap
.Map1Vertex3
.u1
= u1
;
862 ctx
->EvalMap
.Map1Vertex3
.u2
= u2
;
863 ctx
->EvalMap
.Map1Vertex3
.du
= 1.0 / (u2
- u1
);
864 if (ctx
->EvalMap
.Map1Vertex3
.Points
865 && !ctx
->EvalMap
.Map1Vertex3
.Retain
) {
866 free( ctx
->EvalMap
.Map1Vertex3
.Points
);
868 ctx
->EvalMap
.Map1Vertex3
.Points
= (GLfloat
*) points
;
869 ctx
->EvalMap
.Map1Vertex3
.Retain
= retain
;
871 case GL_MAP1_VERTEX_4
:
872 ctx
->EvalMap
.Map1Vertex4
.Order
= order
;
873 ctx
->EvalMap
.Map1Vertex4
.u1
= u1
;
874 ctx
->EvalMap
.Map1Vertex4
.u2
= u2
;
875 ctx
->EvalMap
.Map1Vertex4
.du
= 1.0 / (u2
- u1
);
876 if (ctx
->EvalMap
.Map1Vertex4
.Points
877 && !ctx
->EvalMap
.Map1Vertex4
.Retain
) {
878 free( ctx
->EvalMap
.Map1Vertex4
.Points
);
880 ctx
->EvalMap
.Map1Vertex4
.Points
= (GLfloat
*) points
;
881 ctx
->EvalMap
.Map1Vertex4
.Retain
= retain
;
884 ctx
->EvalMap
.Map1Index
.Order
= order
;
885 ctx
->EvalMap
.Map1Index
.u1
= u1
;
886 ctx
->EvalMap
.Map1Index
.u2
= u2
;
887 ctx
->EvalMap
.Map1Index
.du
= 1.0 / (u2
- u1
);
888 if (ctx
->EvalMap
.Map1Index
.Points
889 && !ctx
->EvalMap
.Map1Index
.Retain
) {
890 free( ctx
->EvalMap
.Map1Index
.Points
);
892 ctx
->EvalMap
.Map1Index
.Points
= (GLfloat
*) points
;
893 ctx
->EvalMap
.Map1Index
.Retain
= retain
;
895 case GL_MAP1_COLOR_4
:
896 ctx
->EvalMap
.Map1Color4
.Order
= order
;
897 ctx
->EvalMap
.Map1Color4
.u1
= u1
;
898 ctx
->EvalMap
.Map1Color4
.u2
= u2
;
899 ctx
->EvalMap
.Map1Color4
.du
= 1.0 / (u2
- u1
);
900 if (ctx
->EvalMap
.Map1Color4
.Points
901 && !ctx
->EvalMap
.Map1Color4
.Retain
) {
902 free( ctx
->EvalMap
.Map1Color4
.Points
);
904 ctx
->EvalMap
.Map1Color4
.Points
= (GLfloat
*) points
;
905 ctx
->EvalMap
.Map1Color4
.Retain
= retain
;
908 ctx
->EvalMap
.Map1Normal
.Order
= order
;
909 ctx
->EvalMap
.Map1Normal
.u1
= u1
;
910 ctx
->EvalMap
.Map1Normal
.u2
= u2
;
911 ctx
->EvalMap
.Map1Normal
.du
= 1.0 / (u2
- u1
);
912 if (ctx
->EvalMap
.Map1Normal
.Points
913 && !ctx
->EvalMap
.Map1Normal
.Retain
) {
914 free( ctx
->EvalMap
.Map1Normal
.Points
);
916 ctx
->EvalMap
.Map1Normal
.Points
= (GLfloat
*) points
;
917 ctx
->EvalMap
.Map1Normal
.Retain
= retain
;
919 case GL_MAP1_TEXTURE_COORD_1
:
920 ctx
->EvalMap
.Map1Texture1
.Order
= order
;
921 ctx
->EvalMap
.Map1Texture1
.u1
= u1
;
922 ctx
->EvalMap
.Map1Texture1
.u2
= u2
;
923 ctx
->EvalMap
.Map1Texture1
.du
= 1.0 / (u2
- u1
);
924 if (ctx
->EvalMap
.Map1Texture1
.Points
925 && !ctx
->EvalMap
.Map1Texture1
.Retain
) {
926 free( ctx
->EvalMap
.Map1Texture1
.Points
);
928 ctx
->EvalMap
.Map1Texture1
.Points
= (GLfloat
*) points
;
929 ctx
->EvalMap
.Map1Texture1
.Retain
= retain
;
931 case GL_MAP1_TEXTURE_COORD_2
:
932 ctx
->EvalMap
.Map1Texture2
.Order
= order
;
933 ctx
->EvalMap
.Map1Texture2
.u1
= u1
;
934 ctx
->EvalMap
.Map1Texture2
.u2
= u2
;
935 ctx
->EvalMap
.Map1Texture2
.du
= 1.0 / (u2
- u1
);
936 if (ctx
->EvalMap
.Map1Texture2
.Points
937 && !ctx
->EvalMap
.Map1Texture2
.Retain
) {
938 free( ctx
->EvalMap
.Map1Texture2
.Points
);
940 ctx
->EvalMap
.Map1Texture2
.Points
= (GLfloat
*) points
;
941 ctx
->EvalMap
.Map1Texture2
.Retain
= retain
;
943 case GL_MAP1_TEXTURE_COORD_3
:
944 ctx
->EvalMap
.Map1Texture3
.Order
= order
;
945 ctx
->EvalMap
.Map1Texture3
.u1
= u1
;
946 ctx
->EvalMap
.Map1Texture3
.u2
= u2
;
947 ctx
->EvalMap
.Map1Texture3
.du
= 1.0 / (u2
- u1
);
948 if (ctx
->EvalMap
.Map1Texture3
.Points
949 && !ctx
->EvalMap
.Map1Texture3
.Retain
) {
950 free( ctx
->EvalMap
.Map1Texture3
.Points
);
952 ctx
->EvalMap
.Map1Texture3
.Points
= (GLfloat
*) points
;
953 ctx
->EvalMap
.Map1Texture3
.Retain
= retain
;
955 case GL_MAP1_TEXTURE_COORD_4
:
956 ctx
->EvalMap
.Map1Texture4
.Order
= order
;
957 ctx
->EvalMap
.Map1Texture4
.u1
= u1
;
958 ctx
->EvalMap
.Map1Texture4
.u2
= u2
;
959 ctx
->EvalMap
.Map1Texture4
.du
= 1.0 / (u2
- u1
);
960 if (ctx
->EvalMap
.Map1Texture4
.Points
961 && !ctx
->EvalMap
.Map1Texture4
.Retain
) {
962 free( ctx
->EvalMap
.Map1Texture4
.Points
);
964 ctx
->EvalMap
.Map1Texture4
.Points
= (GLfloat
*) points
;
965 ctx
->EvalMap
.Map1Texture4
.Retain
= retain
;
968 gl_error( ctx
, GL_INVALID_ENUM
, "glMap1(target)" );
976 * Note that the array of control points must be 'unpacked' at this time.
977 * Input: retain - if TRUE, this control point data is also in a display
978 * list and can't be freed until the list is freed.
980 void gl_Map2f( GLcontext
* ctx
, GLenum target
,
981 GLfloat u1
, GLfloat u2
, GLint ustride
, GLint uorder
,
982 GLfloat v1
, GLfloat v2
, GLint vstride
, GLint vorder
,
983 const GLfloat
*points
, GLboolean retain
)
987 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glMap2");
990 gl_error( ctx
, GL_INVALID_VALUE
, "glMap2(u1,u2)" );
995 gl_error( ctx
, GL_INVALID_VALUE
, "glMap2(v1,v2)" );
999 if (uorder
<1 || uorder
>MAX_EVAL_ORDER
) {
1000 gl_error( ctx
, GL_INVALID_VALUE
, "glMap2(uorder)" );
1004 if (vorder
<1 || vorder
>MAX_EVAL_ORDER
) {
1005 gl_error( ctx
, GL_INVALID_VALUE
, "glMap2(vorder)" );
1009 k
= components( target
);
1011 gl_error( ctx
, GL_INVALID_ENUM
, "glMap2(target)" );
1015 gl_error( ctx
, GL_INVALID_VALUE
, "glMap2(ustride)" );
1019 gl_error( ctx
, GL_INVALID_VALUE
, "glMap2(vstride)" );
1024 case GL_MAP2_VERTEX_3
:
1025 ctx
->EvalMap
.Map2Vertex3
.Uorder
= uorder
;
1026 ctx
->EvalMap
.Map2Vertex3
.u1
= u1
;
1027 ctx
->EvalMap
.Map2Vertex3
.u2
= u2
;
1028 ctx
->EvalMap
.Map2Vertex3
.du
= 1.0 / (u2
- u1
);
1029 ctx
->EvalMap
.Map2Vertex3
.Vorder
= vorder
;
1030 ctx
->EvalMap
.Map2Vertex3
.v1
= v1
;
1031 ctx
->EvalMap
.Map2Vertex3
.v2
= v2
;
1032 ctx
->EvalMap
.Map2Vertex3
.dv
= 1.0 / (v2
- v1
);
1033 if (ctx
->EvalMap
.Map2Vertex3
.Points
1034 && !ctx
->EvalMap
.Map2Vertex3
.Retain
) {
1035 free( ctx
->EvalMap
.Map2Vertex3
.Points
);
1037 ctx
->EvalMap
.Map2Vertex3
.Retain
= retain
;
1038 ctx
->EvalMap
.Map2Vertex3
.Points
= (GLfloat
*) points
;
1040 case GL_MAP2_VERTEX_4
:
1041 ctx
->EvalMap
.Map2Vertex4
.Uorder
= uorder
;
1042 ctx
->EvalMap
.Map2Vertex4
.u1
= u1
;
1043 ctx
->EvalMap
.Map2Vertex4
.u2
= u2
;
1044 ctx
->EvalMap
.Map2Vertex4
.du
= 1.0 / (u2
- u1
);
1045 ctx
->EvalMap
.Map2Vertex4
.Vorder
= vorder
;
1046 ctx
->EvalMap
.Map2Vertex4
.v1
= v1
;
1047 ctx
->EvalMap
.Map2Vertex4
.v2
= v2
;
1048 ctx
->EvalMap
.Map2Vertex4
.dv
= 1.0 / (v2
- v1
);
1049 if (ctx
->EvalMap
.Map2Vertex4
.Points
1050 && !ctx
->EvalMap
.Map2Vertex4
.Retain
) {
1051 free( ctx
->EvalMap
.Map2Vertex4
.Points
);
1053 ctx
->EvalMap
.Map2Vertex4
.Points
= (GLfloat
*) points
;
1054 ctx
->EvalMap
.Map2Vertex4
.Retain
= retain
;
1057 ctx
->EvalMap
.Map2Index
.Uorder
= uorder
;
1058 ctx
->EvalMap
.Map2Index
.u1
= u1
;
1059 ctx
->EvalMap
.Map2Index
.u2
= u2
;
1060 ctx
->EvalMap
.Map2Index
.du
= 1.0 / (u2
- u1
);
1061 ctx
->EvalMap
.Map2Index
.Vorder
= vorder
;
1062 ctx
->EvalMap
.Map2Index
.v1
= v1
;
1063 ctx
->EvalMap
.Map2Index
.v2
= v2
;
1064 ctx
->EvalMap
.Map2Index
.dv
= 1.0 / (v2
- v1
);
1065 if (ctx
->EvalMap
.Map2Index
.Points
1066 && !ctx
->EvalMap
.Map2Index
.Retain
) {
1067 free( ctx
->EvalMap
.Map2Index
.Points
);
1069 ctx
->EvalMap
.Map2Index
.Retain
= retain
;
1070 ctx
->EvalMap
.Map2Index
.Points
= (GLfloat
*) points
;
1072 case GL_MAP2_COLOR_4
:
1073 ctx
->EvalMap
.Map2Color4
.Uorder
= uorder
;
1074 ctx
->EvalMap
.Map2Color4
.u1
= u1
;
1075 ctx
->EvalMap
.Map2Color4
.u2
= u2
;
1076 ctx
->EvalMap
.Map2Color4
.du
= 1.0 / (u2
- u1
);
1077 ctx
->EvalMap
.Map2Color4
.Vorder
= vorder
;
1078 ctx
->EvalMap
.Map2Color4
.v1
= v1
;
1079 ctx
->EvalMap
.Map2Color4
.v2
= v2
;
1080 ctx
->EvalMap
.Map2Color4
.dv
= 1.0 / (v2
- v1
);
1081 if (ctx
->EvalMap
.Map2Color4
.Points
1082 && !ctx
->EvalMap
.Map2Color4
.Retain
) {
1083 free( ctx
->EvalMap
.Map2Color4
.Points
);
1085 ctx
->EvalMap
.Map2Color4
.Retain
= retain
;
1086 ctx
->EvalMap
.Map2Color4
.Points
= (GLfloat
*) points
;
1088 case GL_MAP2_NORMAL
:
1089 ctx
->EvalMap
.Map2Normal
.Uorder
= uorder
;
1090 ctx
->EvalMap
.Map2Normal
.u1
= u1
;
1091 ctx
->EvalMap
.Map2Normal
.u2
= u2
;
1092 ctx
->EvalMap
.Map2Normal
.du
= 1.0 / (u2
- u1
);
1093 ctx
->EvalMap
.Map2Normal
.Vorder
= vorder
;
1094 ctx
->EvalMap
.Map2Normal
.v1
= v1
;
1095 ctx
->EvalMap
.Map2Normal
.v2
= v2
;
1096 ctx
->EvalMap
.Map2Normal
.dv
= 1.0 / (v2
- v1
);
1097 if (ctx
->EvalMap
.Map2Normal
.Points
1098 && !ctx
->EvalMap
.Map2Normal
.Retain
) {
1099 free( ctx
->EvalMap
.Map2Normal
.Points
);
1101 ctx
->EvalMap
.Map2Normal
.Retain
= retain
;
1102 ctx
->EvalMap
.Map2Normal
.Points
= (GLfloat
*) points
;
1104 case GL_MAP2_TEXTURE_COORD_1
:
1105 ctx
->EvalMap
.Map2Texture1
.Uorder
= uorder
;
1106 ctx
->EvalMap
.Map2Texture1
.u1
= u1
;
1107 ctx
->EvalMap
.Map2Texture1
.u2
= u2
;
1108 ctx
->EvalMap
.Map2Texture1
.du
= 1.0 / (u2
- u1
);
1109 ctx
->EvalMap
.Map2Texture1
.Vorder
= vorder
;
1110 ctx
->EvalMap
.Map2Texture1
.v1
= v1
;
1111 ctx
->EvalMap
.Map2Texture1
.v2
= v2
;
1112 ctx
->EvalMap
.Map2Texture1
.dv
= 1.0 / (v2
- v1
);
1113 if (ctx
->EvalMap
.Map2Texture1
.Points
1114 && !ctx
->EvalMap
.Map2Texture1
.Retain
) {
1115 free( ctx
->EvalMap
.Map2Texture1
.Points
);
1117 ctx
->EvalMap
.Map2Texture1
.Retain
= retain
;
1118 ctx
->EvalMap
.Map2Texture1
.Points
= (GLfloat
*) points
;
1120 case GL_MAP2_TEXTURE_COORD_2
:
1121 ctx
->EvalMap
.Map2Texture2
.Uorder
= uorder
;
1122 ctx
->EvalMap
.Map2Texture2
.u1
= u1
;
1123 ctx
->EvalMap
.Map2Texture2
.u2
= u2
;
1124 ctx
->EvalMap
.Map2Texture2
.du
= 1.0 / (u2
- u1
);
1125 ctx
->EvalMap
.Map2Texture2
.Vorder
= vorder
;
1126 ctx
->EvalMap
.Map2Texture2
.v1
= v1
;
1127 ctx
->EvalMap
.Map2Texture2
.v2
= v2
;
1128 ctx
->EvalMap
.Map2Texture2
.dv
= 1.0 / (v2
- v1
);
1129 if (ctx
->EvalMap
.Map2Texture2
.Points
1130 && !ctx
->EvalMap
.Map2Texture2
.Retain
) {
1131 free( ctx
->EvalMap
.Map2Texture2
.Points
);
1133 ctx
->EvalMap
.Map2Texture2
.Retain
= retain
;
1134 ctx
->EvalMap
.Map2Texture2
.Points
= (GLfloat
*) points
;
1136 case GL_MAP2_TEXTURE_COORD_3
:
1137 ctx
->EvalMap
.Map2Texture3
.Uorder
= uorder
;
1138 ctx
->EvalMap
.Map2Texture3
.u1
= u1
;
1139 ctx
->EvalMap
.Map2Texture3
.u2
= u2
;
1140 ctx
->EvalMap
.Map2Texture3
.du
= 1.0 / (u2
- u1
);
1141 ctx
->EvalMap
.Map2Texture3
.Vorder
= vorder
;
1142 ctx
->EvalMap
.Map2Texture3
.v1
= v1
;
1143 ctx
->EvalMap
.Map2Texture3
.v2
= v2
;
1144 ctx
->EvalMap
.Map2Texture3
.dv
= 1.0 / (v2
- v1
);
1145 if (ctx
->EvalMap
.Map2Texture3
.Points
1146 && !ctx
->EvalMap
.Map2Texture3
.Retain
) {
1147 free( ctx
->EvalMap
.Map2Texture3
.Points
);
1149 ctx
->EvalMap
.Map2Texture3
.Retain
= retain
;
1150 ctx
->EvalMap
.Map2Texture3
.Points
= (GLfloat
*) points
;
1152 case GL_MAP2_TEXTURE_COORD_4
:
1153 ctx
->EvalMap
.Map2Texture4
.Uorder
= uorder
;
1154 ctx
->EvalMap
.Map2Texture4
.u1
= u1
;
1155 ctx
->EvalMap
.Map2Texture4
.u2
= u2
;
1156 ctx
->EvalMap
.Map2Texture4
.du
= 1.0 / (u2
- u1
);
1157 ctx
->EvalMap
.Map2Texture4
.Vorder
= vorder
;
1158 ctx
->EvalMap
.Map2Texture4
.v1
= v1
;
1159 ctx
->EvalMap
.Map2Texture4
.v2
= v2
;
1160 ctx
->EvalMap
.Map2Texture4
.dv
= 1.0 / (v2
- v1
);
1161 if (ctx
->EvalMap
.Map2Texture4
.Points
1162 && !ctx
->EvalMap
.Map2Texture4
.Retain
) {
1163 free( ctx
->EvalMap
.Map2Texture4
.Points
);
1165 ctx
->EvalMap
.Map2Texture4
.Retain
= retain
;
1166 ctx
->EvalMap
.Map2Texture4
.Points
= (GLfloat
*) points
;
1169 gl_error( ctx
, GL_INVALID_ENUM
, "glMap2(target)" );
1177 void gl_GetMapdv( GLcontext
* ctx
, GLenum target
, GLenum query
, GLdouble
*v
)
1185 case GL_MAP1_COLOR_4
:
1186 data
= ctx
->EvalMap
.Map1Color4
.Points
;
1187 n
= ctx
->EvalMap
.Map1Color4
.Order
* 4;
1190 data
= ctx
->EvalMap
.Map1Index
.Points
;
1191 n
= ctx
->EvalMap
.Map1Index
.Order
;
1193 case GL_MAP1_NORMAL
:
1194 data
= ctx
->EvalMap
.Map1Normal
.Points
;
1195 n
= ctx
->EvalMap
.Map1Normal
.Order
* 3;
1197 case GL_MAP1_TEXTURE_COORD_1
:
1198 data
= ctx
->EvalMap
.Map1Texture1
.Points
;
1199 n
= ctx
->EvalMap
.Map1Texture1
.Order
* 1;
1201 case GL_MAP1_TEXTURE_COORD_2
:
1202 data
= ctx
->EvalMap
.Map1Texture2
.Points
;
1203 n
= ctx
->EvalMap
.Map1Texture2
.Order
* 2;
1205 case GL_MAP1_TEXTURE_COORD_3
:
1206 data
= ctx
->EvalMap
.Map1Texture3
.Points
;
1207 n
= ctx
->EvalMap
.Map1Texture3
.Order
* 3;
1209 case GL_MAP1_TEXTURE_COORD_4
:
1210 data
= ctx
->EvalMap
.Map1Texture4
.Points
;
1211 n
= ctx
->EvalMap
.Map1Texture4
.Order
* 4;
1213 case GL_MAP1_VERTEX_3
:
1214 data
= ctx
->EvalMap
.Map1Vertex3
.Points
;
1215 n
= ctx
->EvalMap
.Map1Vertex3
.Order
* 3;
1217 case GL_MAP1_VERTEX_4
:
1218 data
= ctx
->EvalMap
.Map1Vertex4
.Points
;
1219 n
= ctx
->EvalMap
.Map1Vertex4
.Order
* 4;
1221 case GL_MAP2_COLOR_4
:
1222 data
= ctx
->EvalMap
.Map2Color4
.Points
;
1223 n
= ctx
->EvalMap
.Map2Color4
.Uorder
1224 * ctx
->EvalMap
.Map2Color4
.Vorder
* 4;
1227 data
= ctx
->EvalMap
.Map2Index
.Points
;
1228 n
= ctx
->EvalMap
.Map2Index
.Uorder
1229 * ctx
->EvalMap
.Map2Index
.Vorder
;
1231 case GL_MAP2_NORMAL
:
1232 data
= ctx
->EvalMap
.Map2Normal
.Points
;
1233 n
= ctx
->EvalMap
.Map2Normal
.Uorder
1234 * ctx
->EvalMap
.Map2Normal
.Vorder
* 3;
1236 case GL_MAP2_TEXTURE_COORD_1
:
1237 data
= ctx
->EvalMap
.Map2Texture1
.Points
;
1238 n
= ctx
->EvalMap
.Map2Texture1
.Uorder
1239 * ctx
->EvalMap
.Map2Texture1
.Vorder
* 1;
1241 case GL_MAP2_TEXTURE_COORD_2
:
1242 data
= ctx
->EvalMap
.Map2Texture2
.Points
;
1243 n
= ctx
->EvalMap
.Map2Texture2
.Uorder
1244 * ctx
->EvalMap
.Map2Texture2
.Vorder
* 2;
1246 case GL_MAP2_TEXTURE_COORD_3
:
1247 data
= ctx
->EvalMap
.Map2Texture3
.Points
;
1248 n
= ctx
->EvalMap
.Map2Texture3
.Uorder
1249 * ctx
->EvalMap
.Map2Texture3
.Vorder
* 3;
1251 case GL_MAP2_TEXTURE_COORD_4
:
1252 data
= ctx
->EvalMap
.Map2Texture4
.Points
;
1253 n
= ctx
->EvalMap
.Map2Texture4
.Uorder
1254 * ctx
->EvalMap
.Map2Texture4
.Vorder
* 4;
1256 case GL_MAP2_VERTEX_3
:
1257 data
= ctx
->EvalMap
.Map2Vertex3
.Points
;
1258 n
= ctx
->EvalMap
.Map2Vertex3
.Uorder
1259 * ctx
->EvalMap
.Map2Vertex3
.Vorder
* 3;
1261 case GL_MAP2_VERTEX_4
:
1262 data
= ctx
->EvalMap
.Map2Vertex4
.Points
;
1263 n
= ctx
->EvalMap
.Map2Vertex4
.Uorder
1264 * ctx
->EvalMap
.Map2Vertex4
.Vorder
* 4;
1267 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapdv(target)" );
1278 case GL_MAP1_COLOR_4
:
1279 *v
= ctx
->EvalMap
.Map1Color4
.Order
;
1282 *v
= ctx
->EvalMap
.Map1Index
.Order
;
1284 case GL_MAP1_NORMAL
:
1285 *v
= ctx
->EvalMap
.Map1Normal
.Order
;
1287 case GL_MAP1_TEXTURE_COORD_1
:
1288 *v
= ctx
->EvalMap
.Map1Texture1
.Order
;
1290 case GL_MAP1_TEXTURE_COORD_2
:
1291 *v
= ctx
->EvalMap
.Map1Texture2
.Order
;
1293 case GL_MAP1_TEXTURE_COORD_3
:
1294 *v
= ctx
->EvalMap
.Map1Texture3
.Order
;
1296 case GL_MAP1_TEXTURE_COORD_4
:
1297 *v
= ctx
->EvalMap
.Map1Texture4
.Order
;
1299 case GL_MAP1_VERTEX_3
:
1300 *v
= ctx
->EvalMap
.Map1Vertex3
.Order
;
1302 case GL_MAP1_VERTEX_4
:
1303 *v
= ctx
->EvalMap
.Map1Vertex4
.Order
;
1305 case GL_MAP2_COLOR_4
:
1306 v
[0] = ctx
->EvalMap
.Map2Color4
.Uorder
;
1307 v
[1] = ctx
->EvalMap
.Map2Color4
.Vorder
;
1310 v
[0] = ctx
->EvalMap
.Map2Index
.Uorder
;
1311 v
[1] = ctx
->EvalMap
.Map2Index
.Vorder
;
1313 case GL_MAP2_NORMAL
:
1314 v
[0] = ctx
->EvalMap
.Map2Normal
.Uorder
;
1315 v
[1] = ctx
->EvalMap
.Map2Normal
.Vorder
;
1317 case GL_MAP2_TEXTURE_COORD_1
:
1318 v
[0] = ctx
->EvalMap
.Map2Texture1
.Uorder
;
1319 v
[1] = ctx
->EvalMap
.Map2Texture1
.Vorder
;
1321 case GL_MAP2_TEXTURE_COORD_2
:
1322 v
[0] = ctx
->EvalMap
.Map2Texture2
.Uorder
;
1323 v
[1] = ctx
->EvalMap
.Map2Texture2
.Vorder
;
1325 case GL_MAP2_TEXTURE_COORD_3
:
1326 v
[0] = ctx
->EvalMap
.Map2Texture3
.Uorder
;
1327 v
[1] = ctx
->EvalMap
.Map2Texture3
.Vorder
;
1329 case GL_MAP2_TEXTURE_COORD_4
:
1330 v
[0] = ctx
->EvalMap
.Map2Texture4
.Uorder
;
1331 v
[1] = ctx
->EvalMap
.Map2Texture4
.Vorder
;
1333 case GL_MAP2_VERTEX_3
:
1334 v
[0] = ctx
->EvalMap
.Map2Vertex3
.Uorder
;
1335 v
[1] = ctx
->EvalMap
.Map2Vertex3
.Vorder
;
1337 case GL_MAP2_VERTEX_4
:
1338 v
[0] = ctx
->EvalMap
.Map2Vertex4
.Uorder
;
1339 v
[1] = ctx
->EvalMap
.Map2Vertex4
.Vorder
;
1342 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapdv(target)" );
1348 case GL_MAP1_COLOR_4
:
1349 v
[0] = ctx
->EvalMap
.Map1Color4
.u1
;
1350 v
[1] = ctx
->EvalMap
.Map1Color4
.u2
;
1353 v
[0] = ctx
->EvalMap
.Map1Index
.u1
;
1354 v
[1] = ctx
->EvalMap
.Map1Index
.u2
;
1356 case GL_MAP1_NORMAL
:
1357 v
[0] = ctx
->EvalMap
.Map1Normal
.u1
;
1358 v
[1] = ctx
->EvalMap
.Map1Normal
.u2
;
1360 case GL_MAP1_TEXTURE_COORD_1
:
1361 v
[0] = ctx
->EvalMap
.Map1Texture1
.u1
;
1362 v
[1] = ctx
->EvalMap
.Map1Texture1
.u2
;
1364 case GL_MAP1_TEXTURE_COORD_2
:
1365 v
[0] = ctx
->EvalMap
.Map1Texture2
.u1
;
1366 v
[1] = ctx
->EvalMap
.Map1Texture2
.u2
;
1368 case GL_MAP1_TEXTURE_COORD_3
:
1369 v
[0] = ctx
->EvalMap
.Map1Texture3
.u1
;
1370 v
[1] = ctx
->EvalMap
.Map1Texture3
.u2
;
1372 case GL_MAP1_TEXTURE_COORD_4
:
1373 v
[0] = ctx
->EvalMap
.Map1Texture4
.u1
;
1374 v
[1] = ctx
->EvalMap
.Map1Texture4
.u2
;
1376 case GL_MAP1_VERTEX_3
:
1377 v
[0] = ctx
->EvalMap
.Map1Vertex3
.u1
;
1378 v
[1] = ctx
->EvalMap
.Map1Vertex3
.u2
;
1380 case GL_MAP1_VERTEX_4
:
1381 v
[0] = ctx
->EvalMap
.Map1Vertex4
.u1
;
1382 v
[1] = ctx
->EvalMap
.Map1Vertex4
.u2
;
1384 case GL_MAP2_COLOR_4
:
1385 v
[0] = ctx
->EvalMap
.Map2Color4
.u1
;
1386 v
[1] = ctx
->EvalMap
.Map2Color4
.u2
;
1387 v
[2] = ctx
->EvalMap
.Map2Color4
.v1
;
1388 v
[3] = ctx
->EvalMap
.Map2Color4
.v2
;
1391 v
[0] = ctx
->EvalMap
.Map2Index
.u1
;
1392 v
[1] = ctx
->EvalMap
.Map2Index
.u2
;
1393 v
[2] = ctx
->EvalMap
.Map2Index
.v1
;
1394 v
[3] = ctx
->EvalMap
.Map2Index
.v2
;
1396 case GL_MAP2_NORMAL
:
1397 v
[0] = ctx
->EvalMap
.Map2Normal
.u1
;
1398 v
[1] = ctx
->EvalMap
.Map2Normal
.u2
;
1399 v
[2] = ctx
->EvalMap
.Map2Normal
.v1
;
1400 v
[3] = ctx
->EvalMap
.Map2Normal
.v2
;
1402 case GL_MAP2_TEXTURE_COORD_1
:
1403 v
[0] = ctx
->EvalMap
.Map2Texture1
.u1
;
1404 v
[1] = ctx
->EvalMap
.Map2Texture1
.u2
;
1405 v
[2] = ctx
->EvalMap
.Map2Texture1
.v1
;
1406 v
[3] = ctx
->EvalMap
.Map2Texture1
.v2
;
1408 case GL_MAP2_TEXTURE_COORD_2
:
1409 v
[0] = ctx
->EvalMap
.Map2Texture2
.u1
;
1410 v
[1] = ctx
->EvalMap
.Map2Texture2
.u2
;
1411 v
[2] = ctx
->EvalMap
.Map2Texture2
.v1
;
1412 v
[3] = ctx
->EvalMap
.Map2Texture2
.v2
;
1414 case GL_MAP2_TEXTURE_COORD_3
:
1415 v
[0] = ctx
->EvalMap
.Map2Texture3
.u1
;
1416 v
[1] = ctx
->EvalMap
.Map2Texture3
.u2
;
1417 v
[2] = ctx
->EvalMap
.Map2Texture3
.v1
;
1418 v
[3] = ctx
->EvalMap
.Map2Texture3
.v2
;
1420 case GL_MAP2_TEXTURE_COORD_4
:
1421 v
[0] = ctx
->EvalMap
.Map2Texture4
.u1
;
1422 v
[1] = ctx
->EvalMap
.Map2Texture4
.u2
;
1423 v
[2] = ctx
->EvalMap
.Map2Texture4
.v1
;
1424 v
[3] = ctx
->EvalMap
.Map2Texture4
.v2
;
1426 case GL_MAP2_VERTEX_3
:
1427 v
[0] = ctx
->EvalMap
.Map2Vertex3
.u1
;
1428 v
[1] = ctx
->EvalMap
.Map2Vertex3
.u2
;
1429 v
[2] = ctx
->EvalMap
.Map2Vertex3
.v1
;
1430 v
[3] = ctx
->EvalMap
.Map2Vertex3
.v2
;
1432 case GL_MAP2_VERTEX_4
:
1433 v
[0] = ctx
->EvalMap
.Map2Vertex4
.u1
;
1434 v
[1] = ctx
->EvalMap
.Map2Vertex4
.u2
;
1435 v
[2] = ctx
->EvalMap
.Map2Vertex4
.v1
;
1436 v
[3] = ctx
->EvalMap
.Map2Vertex4
.v2
;
1439 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapdv(target)" );
1443 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapdv(query)" );
1448 void gl_GetMapfv( GLcontext
* ctx
, GLenum target
, GLenum query
, GLfloat
*v
)
1456 case GL_MAP1_COLOR_4
:
1457 data
= ctx
->EvalMap
.Map1Color4
.Points
;
1458 n
= ctx
->EvalMap
.Map1Color4
.Order
* 4;
1461 data
= ctx
->EvalMap
.Map1Index
.Points
;
1462 n
= ctx
->EvalMap
.Map1Index
.Order
;
1464 case GL_MAP1_NORMAL
:
1465 data
= ctx
->EvalMap
.Map1Normal
.Points
;
1466 n
= ctx
->EvalMap
.Map1Normal
.Order
* 3;
1468 case GL_MAP1_TEXTURE_COORD_1
:
1469 data
= ctx
->EvalMap
.Map1Texture1
.Points
;
1470 n
= ctx
->EvalMap
.Map1Texture1
.Order
* 1;
1472 case GL_MAP1_TEXTURE_COORD_2
:
1473 data
= ctx
->EvalMap
.Map1Texture2
.Points
;
1474 n
= ctx
->EvalMap
.Map1Texture2
.Order
* 2;
1476 case GL_MAP1_TEXTURE_COORD_3
:
1477 data
= ctx
->EvalMap
.Map1Texture3
.Points
;
1478 n
= ctx
->EvalMap
.Map1Texture3
.Order
* 3;
1480 case GL_MAP1_TEXTURE_COORD_4
:
1481 data
= ctx
->EvalMap
.Map1Texture4
.Points
;
1482 n
= ctx
->EvalMap
.Map1Texture4
.Order
* 4;
1484 case GL_MAP1_VERTEX_3
:
1485 data
= ctx
->EvalMap
.Map1Vertex3
.Points
;
1486 n
= ctx
->EvalMap
.Map1Vertex3
.Order
* 3;
1488 case GL_MAP1_VERTEX_4
:
1489 data
= ctx
->EvalMap
.Map1Vertex4
.Points
;
1490 n
= ctx
->EvalMap
.Map1Vertex4
.Order
* 4;
1492 case GL_MAP2_COLOR_4
:
1493 data
= ctx
->EvalMap
.Map2Color4
.Points
;
1494 n
= ctx
->EvalMap
.Map2Color4
.Uorder
1495 * ctx
->EvalMap
.Map2Color4
.Vorder
* 4;
1498 data
= ctx
->EvalMap
.Map2Index
.Points
;
1499 n
= ctx
->EvalMap
.Map2Index
.Uorder
1500 * ctx
->EvalMap
.Map2Index
.Vorder
;
1502 case GL_MAP2_NORMAL
:
1503 data
= ctx
->EvalMap
.Map2Normal
.Points
;
1504 n
= ctx
->EvalMap
.Map2Normal
.Uorder
1505 * ctx
->EvalMap
.Map2Normal
.Vorder
* 3;
1507 case GL_MAP2_TEXTURE_COORD_1
:
1508 data
= ctx
->EvalMap
.Map2Texture1
.Points
;
1509 n
= ctx
->EvalMap
.Map2Texture1
.Uorder
1510 * ctx
->EvalMap
.Map2Texture1
.Vorder
* 1;
1512 case GL_MAP2_TEXTURE_COORD_2
:
1513 data
= ctx
->EvalMap
.Map2Texture2
.Points
;
1514 n
= ctx
->EvalMap
.Map2Texture2
.Uorder
1515 * ctx
->EvalMap
.Map2Texture2
.Vorder
* 2;
1517 case GL_MAP2_TEXTURE_COORD_3
:
1518 data
= ctx
->EvalMap
.Map2Texture3
.Points
;
1519 n
= ctx
->EvalMap
.Map2Texture3
.Uorder
1520 * ctx
->EvalMap
.Map2Texture3
.Vorder
* 3;
1522 case GL_MAP2_TEXTURE_COORD_4
:
1523 data
= ctx
->EvalMap
.Map2Texture4
.Points
;
1524 n
= ctx
->EvalMap
.Map2Texture4
.Uorder
1525 * ctx
->EvalMap
.Map2Texture4
.Vorder
* 4;
1527 case GL_MAP2_VERTEX_3
:
1528 data
= ctx
->EvalMap
.Map2Vertex3
.Points
;
1529 n
= ctx
->EvalMap
.Map2Vertex3
.Uorder
1530 * ctx
->EvalMap
.Map2Vertex3
.Vorder
* 3;
1532 case GL_MAP2_VERTEX_4
:
1533 data
= ctx
->EvalMap
.Map2Vertex4
.Points
;
1534 n
= ctx
->EvalMap
.Map2Vertex4
.Uorder
1535 * ctx
->EvalMap
.Map2Vertex4
.Vorder
* 4;
1538 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapfv(target)" );
1549 case GL_MAP1_COLOR_4
:
1550 *v
= ctx
->EvalMap
.Map1Color4
.Order
;
1553 *v
= ctx
->EvalMap
.Map1Index
.Order
;
1555 case GL_MAP1_NORMAL
:
1556 *v
= ctx
->EvalMap
.Map1Normal
.Order
;
1558 case GL_MAP1_TEXTURE_COORD_1
:
1559 *v
= ctx
->EvalMap
.Map1Texture1
.Order
;
1561 case GL_MAP1_TEXTURE_COORD_2
:
1562 *v
= ctx
->EvalMap
.Map1Texture2
.Order
;
1564 case GL_MAP1_TEXTURE_COORD_3
:
1565 *v
= ctx
->EvalMap
.Map1Texture3
.Order
;
1567 case GL_MAP1_TEXTURE_COORD_4
:
1568 *v
= ctx
->EvalMap
.Map1Texture4
.Order
;
1570 case GL_MAP1_VERTEX_3
:
1571 *v
= ctx
->EvalMap
.Map1Vertex3
.Order
;
1573 case GL_MAP1_VERTEX_4
:
1574 *v
= ctx
->EvalMap
.Map1Vertex4
.Order
;
1576 case GL_MAP2_COLOR_4
:
1577 v
[0] = ctx
->EvalMap
.Map2Color4
.Uorder
;
1578 v
[1] = ctx
->EvalMap
.Map2Color4
.Vorder
;
1581 v
[0] = ctx
->EvalMap
.Map2Index
.Uorder
;
1582 v
[1] = ctx
->EvalMap
.Map2Index
.Vorder
;
1584 case GL_MAP2_NORMAL
:
1585 v
[0] = ctx
->EvalMap
.Map2Normal
.Uorder
;
1586 v
[1] = ctx
->EvalMap
.Map2Normal
.Vorder
;
1588 case GL_MAP2_TEXTURE_COORD_1
:
1589 v
[0] = ctx
->EvalMap
.Map2Texture1
.Uorder
;
1590 v
[1] = ctx
->EvalMap
.Map2Texture1
.Vorder
;
1592 case GL_MAP2_TEXTURE_COORD_2
:
1593 v
[0] = ctx
->EvalMap
.Map2Texture2
.Uorder
;
1594 v
[1] = ctx
->EvalMap
.Map2Texture2
.Vorder
;
1596 case GL_MAP2_TEXTURE_COORD_3
:
1597 v
[0] = ctx
->EvalMap
.Map2Texture3
.Uorder
;
1598 v
[1] = ctx
->EvalMap
.Map2Texture3
.Vorder
;
1600 case GL_MAP2_TEXTURE_COORD_4
:
1601 v
[0] = ctx
->EvalMap
.Map2Texture4
.Uorder
;
1602 v
[1] = ctx
->EvalMap
.Map2Texture4
.Vorder
;
1604 case GL_MAP2_VERTEX_3
:
1605 v
[0] = ctx
->EvalMap
.Map2Vertex3
.Uorder
;
1606 v
[1] = ctx
->EvalMap
.Map2Vertex3
.Vorder
;
1608 case GL_MAP2_VERTEX_4
:
1609 v
[0] = ctx
->EvalMap
.Map2Vertex4
.Uorder
;
1610 v
[1] = ctx
->EvalMap
.Map2Vertex4
.Vorder
;
1613 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapfv(target)" );
1619 case GL_MAP1_COLOR_4
:
1620 v
[0] = ctx
->EvalMap
.Map1Color4
.u1
;
1621 v
[1] = ctx
->EvalMap
.Map1Color4
.u2
;
1624 v
[0] = ctx
->EvalMap
.Map1Index
.u1
;
1625 v
[1] = ctx
->EvalMap
.Map1Index
.u2
;
1627 case GL_MAP1_NORMAL
:
1628 v
[0] = ctx
->EvalMap
.Map1Normal
.u1
;
1629 v
[1] = ctx
->EvalMap
.Map1Normal
.u2
;
1631 case GL_MAP1_TEXTURE_COORD_1
:
1632 v
[0] = ctx
->EvalMap
.Map1Texture1
.u1
;
1633 v
[1] = ctx
->EvalMap
.Map1Texture1
.u2
;
1635 case GL_MAP1_TEXTURE_COORD_2
:
1636 v
[0] = ctx
->EvalMap
.Map1Texture2
.u1
;
1637 v
[1] = ctx
->EvalMap
.Map1Texture2
.u2
;
1639 case GL_MAP1_TEXTURE_COORD_3
:
1640 v
[0] = ctx
->EvalMap
.Map1Texture3
.u1
;
1641 v
[1] = ctx
->EvalMap
.Map1Texture3
.u2
;
1643 case GL_MAP1_TEXTURE_COORD_4
:
1644 v
[0] = ctx
->EvalMap
.Map1Texture4
.u1
;
1645 v
[1] = ctx
->EvalMap
.Map1Texture4
.u2
;
1647 case GL_MAP1_VERTEX_3
:
1648 v
[0] = ctx
->EvalMap
.Map1Vertex3
.u1
;
1649 v
[1] = ctx
->EvalMap
.Map1Vertex3
.u2
;
1651 case GL_MAP1_VERTEX_4
:
1652 v
[0] = ctx
->EvalMap
.Map1Vertex4
.u1
;
1653 v
[1] = ctx
->EvalMap
.Map1Vertex4
.u2
;
1655 case GL_MAP2_COLOR_4
:
1656 v
[0] = ctx
->EvalMap
.Map2Color4
.u1
;
1657 v
[1] = ctx
->EvalMap
.Map2Color4
.u2
;
1658 v
[2] = ctx
->EvalMap
.Map2Color4
.v1
;
1659 v
[3] = ctx
->EvalMap
.Map2Color4
.v2
;
1662 v
[0] = ctx
->EvalMap
.Map2Index
.u1
;
1663 v
[1] = ctx
->EvalMap
.Map2Index
.u2
;
1664 v
[2] = ctx
->EvalMap
.Map2Index
.v1
;
1665 v
[3] = ctx
->EvalMap
.Map2Index
.v2
;
1667 case GL_MAP2_NORMAL
:
1668 v
[0] = ctx
->EvalMap
.Map2Normal
.u1
;
1669 v
[1] = ctx
->EvalMap
.Map2Normal
.u2
;
1670 v
[2] = ctx
->EvalMap
.Map2Normal
.v1
;
1671 v
[3] = ctx
->EvalMap
.Map2Normal
.v2
;
1673 case GL_MAP2_TEXTURE_COORD_1
:
1674 v
[0] = ctx
->EvalMap
.Map2Texture1
.u1
;
1675 v
[1] = ctx
->EvalMap
.Map2Texture1
.u2
;
1676 v
[2] = ctx
->EvalMap
.Map2Texture1
.v1
;
1677 v
[3] = ctx
->EvalMap
.Map2Texture1
.v2
;
1679 case GL_MAP2_TEXTURE_COORD_2
:
1680 v
[0] = ctx
->EvalMap
.Map2Texture2
.u1
;
1681 v
[1] = ctx
->EvalMap
.Map2Texture2
.u2
;
1682 v
[2] = ctx
->EvalMap
.Map2Texture2
.v1
;
1683 v
[3] = ctx
->EvalMap
.Map2Texture2
.v2
;
1685 case GL_MAP2_TEXTURE_COORD_3
:
1686 v
[0] = ctx
->EvalMap
.Map2Texture3
.u1
;
1687 v
[1] = ctx
->EvalMap
.Map2Texture3
.u2
;
1688 v
[2] = ctx
->EvalMap
.Map2Texture3
.v1
;
1689 v
[3] = ctx
->EvalMap
.Map2Texture3
.v2
;
1691 case GL_MAP2_TEXTURE_COORD_4
:
1692 v
[0] = ctx
->EvalMap
.Map2Texture4
.u1
;
1693 v
[1] = ctx
->EvalMap
.Map2Texture4
.u2
;
1694 v
[2] = ctx
->EvalMap
.Map2Texture4
.v1
;
1695 v
[3] = ctx
->EvalMap
.Map2Texture4
.v2
;
1697 case GL_MAP2_VERTEX_3
:
1698 v
[0] = ctx
->EvalMap
.Map2Vertex3
.u1
;
1699 v
[1] = ctx
->EvalMap
.Map2Vertex3
.u2
;
1700 v
[2] = ctx
->EvalMap
.Map2Vertex3
.v1
;
1701 v
[3] = ctx
->EvalMap
.Map2Vertex3
.v2
;
1703 case GL_MAP2_VERTEX_4
:
1704 v
[0] = ctx
->EvalMap
.Map2Vertex4
.u1
;
1705 v
[1] = ctx
->EvalMap
.Map2Vertex4
.u2
;
1706 v
[2] = ctx
->EvalMap
.Map2Vertex4
.v1
;
1707 v
[3] = ctx
->EvalMap
.Map2Vertex4
.v2
;
1710 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapfv(target)" );
1714 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapfv(query)" );
1719 void gl_GetMapiv( GLcontext
* ctx
, GLenum target
, GLenum query
, GLint
*v
)
1727 case GL_MAP1_COLOR_4
:
1728 data
= ctx
->EvalMap
.Map1Color4
.Points
;
1729 n
= ctx
->EvalMap
.Map1Color4
.Order
* 4;
1732 data
= ctx
->EvalMap
.Map1Index
.Points
;
1733 n
= ctx
->EvalMap
.Map1Index
.Order
;
1735 case GL_MAP1_NORMAL
:
1736 data
= ctx
->EvalMap
.Map1Normal
.Points
;
1737 n
= ctx
->EvalMap
.Map1Normal
.Order
* 3;
1739 case GL_MAP1_TEXTURE_COORD_1
:
1740 data
= ctx
->EvalMap
.Map1Texture1
.Points
;
1741 n
= ctx
->EvalMap
.Map1Texture1
.Order
* 1;
1743 case GL_MAP1_TEXTURE_COORD_2
:
1744 data
= ctx
->EvalMap
.Map1Texture2
.Points
;
1745 n
= ctx
->EvalMap
.Map1Texture2
.Order
* 2;
1747 case GL_MAP1_TEXTURE_COORD_3
:
1748 data
= ctx
->EvalMap
.Map1Texture3
.Points
;
1749 n
= ctx
->EvalMap
.Map1Texture3
.Order
* 3;
1751 case GL_MAP1_TEXTURE_COORD_4
:
1752 data
= ctx
->EvalMap
.Map1Texture4
.Points
;
1753 n
= ctx
->EvalMap
.Map1Texture4
.Order
* 4;
1755 case GL_MAP1_VERTEX_3
:
1756 data
= ctx
->EvalMap
.Map1Vertex3
.Points
;
1757 n
= ctx
->EvalMap
.Map1Vertex3
.Order
* 3;
1759 case GL_MAP1_VERTEX_4
:
1760 data
= ctx
->EvalMap
.Map1Vertex4
.Points
;
1761 n
= ctx
->EvalMap
.Map1Vertex4
.Order
* 4;
1763 case GL_MAP2_COLOR_4
:
1764 data
= ctx
->EvalMap
.Map2Color4
.Points
;
1765 n
= ctx
->EvalMap
.Map2Color4
.Uorder
1766 * ctx
->EvalMap
.Map2Color4
.Vorder
* 4;
1769 data
= ctx
->EvalMap
.Map2Index
.Points
;
1770 n
= ctx
->EvalMap
.Map2Index
.Uorder
1771 * ctx
->EvalMap
.Map2Index
.Vorder
;
1773 case GL_MAP2_NORMAL
:
1774 data
= ctx
->EvalMap
.Map2Normal
.Points
;
1775 n
= ctx
->EvalMap
.Map2Normal
.Uorder
1776 * ctx
->EvalMap
.Map2Normal
.Vorder
* 3;
1778 case GL_MAP2_TEXTURE_COORD_1
:
1779 data
= ctx
->EvalMap
.Map2Texture1
.Points
;
1780 n
= ctx
->EvalMap
.Map2Texture1
.Uorder
1781 * ctx
->EvalMap
.Map2Texture1
.Vorder
* 1;
1783 case GL_MAP2_TEXTURE_COORD_2
:
1784 data
= ctx
->EvalMap
.Map2Texture2
.Points
;
1785 n
= ctx
->EvalMap
.Map2Texture2
.Uorder
1786 * ctx
->EvalMap
.Map2Texture2
.Vorder
* 2;
1788 case GL_MAP2_TEXTURE_COORD_3
:
1789 data
= ctx
->EvalMap
.Map2Texture3
.Points
;
1790 n
= ctx
->EvalMap
.Map2Texture3
.Uorder
1791 * ctx
->EvalMap
.Map2Texture3
.Vorder
* 3;
1793 case GL_MAP2_TEXTURE_COORD_4
:
1794 data
= ctx
->EvalMap
.Map2Texture4
.Points
;
1795 n
= ctx
->EvalMap
.Map2Texture4
.Uorder
1796 * ctx
->EvalMap
.Map2Texture4
.Vorder
* 4;
1798 case GL_MAP2_VERTEX_3
:
1799 data
= ctx
->EvalMap
.Map2Vertex3
.Points
;
1800 n
= ctx
->EvalMap
.Map2Vertex3
.Uorder
1801 * ctx
->EvalMap
.Map2Vertex3
.Vorder
* 3;
1803 case GL_MAP2_VERTEX_4
:
1804 data
= ctx
->EvalMap
.Map2Vertex4
.Points
;
1805 n
= ctx
->EvalMap
.Map2Vertex4
.Uorder
1806 * ctx
->EvalMap
.Map2Vertex4
.Vorder
* 4;
1809 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapiv(target)" );
1814 v
[i
] = ROUNDF(data
[i
]);
1820 case GL_MAP1_COLOR_4
:
1821 *v
= ctx
->EvalMap
.Map1Color4
.Order
;
1824 *v
= ctx
->EvalMap
.Map1Index
.Order
;
1826 case GL_MAP1_NORMAL
:
1827 *v
= ctx
->EvalMap
.Map1Normal
.Order
;
1829 case GL_MAP1_TEXTURE_COORD_1
:
1830 *v
= ctx
->EvalMap
.Map1Texture1
.Order
;
1832 case GL_MAP1_TEXTURE_COORD_2
:
1833 *v
= ctx
->EvalMap
.Map1Texture2
.Order
;
1835 case GL_MAP1_TEXTURE_COORD_3
:
1836 *v
= ctx
->EvalMap
.Map1Texture3
.Order
;
1838 case GL_MAP1_TEXTURE_COORD_4
:
1839 *v
= ctx
->EvalMap
.Map1Texture4
.Order
;
1841 case GL_MAP1_VERTEX_3
:
1842 *v
= ctx
->EvalMap
.Map1Vertex3
.Order
;
1844 case GL_MAP1_VERTEX_4
:
1845 *v
= ctx
->EvalMap
.Map1Vertex4
.Order
;
1847 case GL_MAP2_COLOR_4
:
1848 v
[0] = ctx
->EvalMap
.Map2Color4
.Uorder
;
1849 v
[1] = ctx
->EvalMap
.Map2Color4
.Vorder
;
1852 v
[0] = ctx
->EvalMap
.Map2Index
.Uorder
;
1853 v
[1] = ctx
->EvalMap
.Map2Index
.Vorder
;
1855 case GL_MAP2_NORMAL
:
1856 v
[0] = ctx
->EvalMap
.Map2Normal
.Uorder
;
1857 v
[1] = ctx
->EvalMap
.Map2Normal
.Vorder
;
1859 case GL_MAP2_TEXTURE_COORD_1
:
1860 v
[0] = ctx
->EvalMap
.Map2Texture1
.Uorder
;
1861 v
[1] = ctx
->EvalMap
.Map2Texture1
.Vorder
;
1863 case GL_MAP2_TEXTURE_COORD_2
:
1864 v
[0] = ctx
->EvalMap
.Map2Texture2
.Uorder
;
1865 v
[1] = ctx
->EvalMap
.Map2Texture2
.Vorder
;
1867 case GL_MAP2_TEXTURE_COORD_3
:
1868 v
[0] = ctx
->EvalMap
.Map2Texture3
.Uorder
;
1869 v
[1] = ctx
->EvalMap
.Map2Texture3
.Vorder
;
1871 case GL_MAP2_TEXTURE_COORD_4
:
1872 v
[0] = ctx
->EvalMap
.Map2Texture4
.Uorder
;
1873 v
[1] = ctx
->EvalMap
.Map2Texture4
.Vorder
;
1875 case GL_MAP2_VERTEX_3
:
1876 v
[0] = ctx
->EvalMap
.Map2Vertex3
.Uorder
;
1877 v
[1] = ctx
->EvalMap
.Map2Vertex3
.Vorder
;
1879 case GL_MAP2_VERTEX_4
:
1880 v
[0] = ctx
->EvalMap
.Map2Vertex4
.Uorder
;
1881 v
[1] = ctx
->EvalMap
.Map2Vertex4
.Vorder
;
1884 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapiv(target)" );
1890 case GL_MAP1_COLOR_4
:
1891 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Color4
.u1
);
1892 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Color4
.u2
);
1895 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Index
.u1
);
1896 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Index
.u2
);
1898 case GL_MAP1_NORMAL
:
1899 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Normal
.u1
);
1900 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Normal
.u2
);
1902 case GL_MAP1_TEXTURE_COORD_1
:
1903 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Texture1
.u1
);
1904 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Texture1
.u2
);
1906 case GL_MAP1_TEXTURE_COORD_2
:
1907 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Texture2
.u1
);
1908 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Texture2
.u2
);
1910 case GL_MAP1_TEXTURE_COORD_3
:
1911 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Texture3
.u1
);
1912 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Texture3
.u2
);
1914 case GL_MAP1_TEXTURE_COORD_4
:
1915 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Texture4
.u1
);
1916 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Texture4
.u2
);
1918 case GL_MAP1_VERTEX_3
:
1919 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Vertex3
.u1
);
1920 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Vertex3
.u2
);
1922 case GL_MAP1_VERTEX_4
:
1923 v
[0] = ROUNDF(ctx
->EvalMap
.Map1Vertex4
.u1
);
1924 v
[1] = ROUNDF(ctx
->EvalMap
.Map1Vertex4
.u2
);
1926 case GL_MAP2_COLOR_4
:
1927 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Color4
.u1
);
1928 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Color4
.u2
);
1929 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Color4
.v1
);
1930 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Color4
.v2
);
1933 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Index
.u1
);
1934 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Index
.u2
);
1935 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Index
.v1
);
1936 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Index
.v2
);
1938 case GL_MAP2_NORMAL
:
1939 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Normal
.u1
);
1940 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Normal
.u2
);
1941 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Normal
.v1
);
1942 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Normal
.v2
);
1944 case GL_MAP2_TEXTURE_COORD_1
:
1945 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Texture1
.u1
);
1946 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Texture1
.u2
);
1947 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Texture1
.v1
);
1948 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Texture1
.v2
);
1950 case GL_MAP2_TEXTURE_COORD_2
:
1951 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Texture2
.u1
);
1952 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Texture2
.u2
);
1953 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Texture2
.v1
);
1954 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Texture2
.v2
);
1956 case GL_MAP2_TEXTURE_COORD_3
:
1957 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Texture3
.u1
);
1958 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Texture3
.u2
);
1959 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Texture3
.v1
);
1960 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Texture3
.v2
);
1962 case GL_MAP2_TEXTURE_COORD_4
:
1963 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Texture4
.u1
);
1964 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Texture4
.u2
);
1965 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Texture4
.v1
);
1966 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Texture4
.v2
);
1968 case GL_MAP2_VERTEX_3
:
1969 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Vertex3
.u1
);
1970 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Vertex3
.u2
);
1971 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Vertex3
.v1
);
1972 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Vertex3
.v2
);
1974 case GL_MAP2_VERTEX_4
:
1975 v
[0] = ROUNDF(ctx
->EvalMap
.Map2Vertex4
.u1
);
1976 v
[1] = ROUNDF(ctx
->EvalMap
.Map2Vertex4
.u2
);
1977 v
[2] = ROUNDF(ctx
->EvalMap
.Map2Vertex4
.v1
);
1978 v
[3] = ROUNDF(ctx
->EvalMap
.Map2Vertex4
.v2
);
1981 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapiv(target)" );
1985 gl_error( ctx
, GL_INVALID_ENUM
, "glGetMapiv(query)" );
1991 void eval_points1( GLfloat outcoord
[][4],
1993 const GLuint
*flags
,
1994 GLfloat du
, GLfloat u1
)
1997 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
1998 if (flags
[i
] & VERT_EVAL_P1
)
1999 outcoord
[i
][0] = coord
[i
][0] * du
+ u1
;
2000 else if (flags
[i
] & VERT_EVAL_ANY
) {
2001 outcoord
[i
][0] = coord
[i
][0];
2002 outcoord
[i
][1] = coord
[i
][1];
2006 void eval_points2( GLfloat outcoord
[][4],
2008 const GLuint
*flags
,
2009 GLfloat du
, GLfloat u1
,
2010 GLfloat dv
, GLfloat v1
)
2013 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2014 if (flags
[i
] & VERT_EVAL_P2
) {
2015 outcoord
[i
][0] = coord
[i
][0] * du
+ u1
;
2016 outcoord
[i
][1] = coord
[i
][1] * dv
+ v1
;
2017 } else if (flags
[i
] & VERT_EVAL_ANY
) {
2018 outcoord
[i
][0] = coord
[i
][0];
2019 outcoord
[i
][1] = coord
[i
][1];
2024 static const GLubyte dirty_flags
[5] = {
2025 0, /* not possible */
2033 GLvector4f
*eval1_4f( GLvector4f
*dest
,
2035 const GLuint
*flags
,
2037 struct gl_1d_map
*map
)
2039 const GLfloat u1
= map
->u1
;
2040 const GLfloat du
= map
->du
;
2041 GLfloat (*to
)[4] = dest
->data
;
2044 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2045 if (flags
[i
] & (VERT_EVAL_C1
|VERT_EVAL_P1
)) {
2046 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2047 ASSIGN_4V(to
[i
], 0,0,0,1);
2048 horner_bezier_curve(map
->Points
, to
[i
], u
, dimension
, map
->Order
);
2052 dest
->size
= MAX2(dest
->size
, dimension
);
2053 dest
->flags
|= dirty_flags
[dimension
];
2058 GLvector1ui
*eval1_1ui( GLvector1ui
*dest
,
2060 const GLuint
*flags
,
2061 struct gl_1d_map
*map
)
2063 const GLfloat u1
= map
->u1
;
2064 const GLfloat du
= map
->du
;
2065 GLuint
*to
= dest
->data
;
2068 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2069 if (flags
[i
] & (VERT_EVAL_C1
|VERT_EVAL_P1
)) {
2070 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2072 horner_bezier_curve(map
->Points
, &tmp
, u
, 1, map
->Order
);
2073 to
[i
] = (GLuint
) (GLint
) tmp
;
2080 GLvector3f
*eval1_norm( GLvector3f
*dest
,
2082 GLuint
*flags
, /* not const */
2083 struct gl_1d_map
*map
)
2085 const GLfloat u1
= map
->u1
;
2086 const GLfloat du
= map
->du
;
2087 GLfloat (*to
)[3] = dest
->data
;
2090 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2091 if (flags
[i
] & (VERT_EVAL_C1
|VERT_EVAL_P1
)) {
2092 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2093 horner_bezier_curve(map
->Points
, to
[i
], u
, 3, map
->Order
);
2094 flags
[i
+1] |= VERT_NORM
; /* reset */
2101 GLvector4ub
*eval1_color( GLvector4ub
*dest
,
2103 GLuint
*flags
, /* not const */
2104 struct gl_1d_map
*map
)
2106 const GLfloat u1
= map
->u1
;
2107 const GLfloat du
= map
->du
;
2108 GLubyte (*to
)[4] = dest
->data
;
2111 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2112 if (flags
[i
] & (VERT_EVAL_C1
|VERT_EVAL_P1
)) {
2113 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2115 horner_bezier_curve(map
->Points
, fcolor
, u
, 4, map
->Order
);
2116 FLOAT_RGBA_TO_UBYTE_RGBA(to
[i
], fcolor
);
2117 flags
[i
+1] |= VERT_RGBA
; /* reset */
2127 GLvector4f
*eval2_obj_norm( GLvector4f
*obj_ptr
,
2128 GLvector3f
*norm_ptr
,
2132 struct gl_2d_map
*map
)
2134 const GLfloat u1
= map
->u1
;
2135 const GLfloat du
= map
->du
;
2136 const GLfloat v1
= map
->v1
;
2137 const GLfloat dv
= map
->dv
;
2138 GLfloat (*obj
)[4] = obj_ptr
->data
;
2139 GLfloat (*normal
)[3] = norm_ptr
->data
;
2142 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2143 if (flags
[i
] & (VERT_EVAL_C2
|VERT_EVAL_P2
)) {
2144 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2145 GLfloat v
= (coord
[i
][1] - v1
) * dv
;
2146 GLfloat du
[4], dv
[4];
2148 ASSIGN_4V(obj
[i
], 0,0,0,1);
2149 de_casteljau_surf(map
->Points
, obj
[i
], du
, dv
, u
, v
, dimension
,
2150 map
->Uorder
, map
->Vorder
);
2152 CROSS3(normal
[i
], du
, dv
);
2153 NORMALIZE_3FV(normal
[i
]);
2154 flags
[i
+1] |= VERT_NORM
;
2158 obj_ptr
->size
= MAX2(obj_ptr
->size
, dimension
);
2159 obj_ptr
->flags
|= dirty_flags
[dimension
];
2164 GLvector4f
*eval2_4f( GLvector4f
*dest
,
2166 const GLuint
*flags
,
2168 struct gl_2d_map
*map
)
2170 const GLfloat u1
= map
->u1
;
2171 const GLfloat du
= map
->du
;
2172 const GLfloat v1
= map
->v1
;
2173 const GLfloat dv
= map
->dv
;
2174 GLfloat (*to
)[4] = dest
->data
;
2177 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2178 if (flags
[i
] & (VERT_EVAL_C2
|VERT_EVAL_P2
)) {
2179 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2180 GLfloat v
= (coord
[i
][1] - v1
) * dv
;
2181 horner_bezier_surf(map
->Points
, to
[i
], u
, v
, dimension
,
2182 map
->Uorder
, map
->Vorder
);
2186 dest
->size
= MAX2(dest
->size
, dimension
);
2187 dest
->flags
|= dirty_flags
[dimension
];
2192 GLvector3f
*eval2_norm( GLvector3f
*dest
,
2195 struct gl_2d_map
*map
)
2197 const GLfloat u1
= map
->u1
;
2198 const GLfloat du
= map
->du
;
2199 const GLfloat v1
= map
->v1
;
2200 const GLfloat dv
= map
->dv
;
2201 GLfloat (*to
)[3] = dest
->data
;
2204 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2205 if (flags
[i
] & (VERT_EVAL_C2
|VERT_EVAL_P2
)) {
2206 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2207 GLfloat v
= (coord
[i
][1] - v1
) * dv
;
2208 horner_bezier_surf(map
->Points
, to
[i
], u
, v
, 3,
2209 map
->Uorder
, map
->Vorder
);
2210 flags
[i
+1] |= VERT_NORM
; /* reset */
2218 GLvector1ui
*eval2_1ui( GLvector1ui
*dest
,
2220 const GLuint
*flags
,
2221 struct gl_2d_map
*map
)
2223 const GLfloat u1
= map
->u1
;
2224 const GLfloat du
= map
->du
;
2225 const GLfloat v1
= map
->v1
;
2226 const GLfloat dv
= map
->dv
;
2227 GLuint
*to
= dest
->data
;
2230 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2231 if (flags
[i
] & (VERT_EVAL_C2
|VERT_EVAL_P2
)) {
2232 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2233 GLfloat v
= (coord
[i
][1] - v1
) * dv
;
2235 horner_bezier_surf(map
->Points
, &tmp
, u
, v
, 1,
2236 map
->Uorder
, map
->Vorder
);
2238 to
[i
] = (GLuint
) (GLint
) tmp
;
2247 GLvector4ub
*eval2_color( GLvector4ub
*dest
,
2250 struct gl_2d_map
*map
)
2252 const GLfloat u1
= map
->u1
;
2253 const GLfloat du
= map
->du
;
2254 const GLfloat v1
= map
->v1
;
2255 const GLfloat dv
= map
->dv
;
2256 GLubyte (*to
)[4] = dest
->data
;
2259 for (i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2260 if (flags
[i
] & (VERT_EVAL_C2
|VERT_EVAL_P2
)) {
2261 GLfloat u
= (coord
[i
][0] - u1
) * du
;
2262 GLfloat v
= (coord
[i
][1] - v1
) * dv
;
2264 horner_bezier_surf(map
->Points
, fcolor
, u
, v
, 4,
2265 map
->Uorder
, map
->Vorder
);
2266 FLOAT_RGBA_TO_UBYTE_RGBA(to
[i
], fcolor
);
2267 flags
[i
+1] |= VERT_RGBA
; /* reset */
2275 GLvector4f
*copy_4f( GLvector4f
*out
, CONST GLvector4f
*in
,
2276 const GLuint
*flags
)
2278 GLfloat (*to
)[4] = out
->data
;
2279 GLfloat (*from
)[4] = in
->data
;
2282 for ( i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2283 if (!(flags
[i
] & VERT_EVAL_ANY
))
2284 COPY_4FV( to
[i
], from
[i
] );
2289 GLvector3f
*copy_3f( GLvector3f
*out
, CONST GLvector3f
*in
,
2290 const GLuint
*flags
)
2292 GLfloat (*to
)[3] = out
->data
;
2293 GLfloat (*from
)[3] = in
->data
;
2296 for ( i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2297 if (!(flags
[i
] & VERT_EVAL_ANY
))
2298 COPY_3V( to
[i
], from
[i
] );
2303 GLvector4ub
*copy_4ub( GLvector4ub
*out
, CONST GLvector4ub
*in
,
2304 const GLuint
*flags
)
2306 GLubyte (*to
)[4] = out
->data
;
2307 GLubyte (*from
)[4] = in
->data
;
2310 for ( i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2311 if (!(flags
[i
] & VERT_EVAL_ANY
))
2312 COPY_4UBV( to
[i
], from
[i
] );
2317 GLvector1ui
*copy_1ui( GLvector1ui
*out
, CONST GLvector1ui
*in
,
2318 const GLuint
*flags
)
2320 GLuint
*to
= out
->data
;
2321 CONST GLuint
*from
= in
->data
;
2324 for ( i
= VB_START
; !(flags
[i
] & VERT_END_VB
) ; i
++)
2325 if (!(flags
[i
] & VERT_EVAL_ANY
))
2332 /* KW: Rewrote this to perform eval on a whole buffer at once.
2333 * Only evaluates active data items, and avoids scribbling
2334 * the source buffer if we are running from a display list.
2336 * If the user (in this case looser) sends eval coordinates
2337 * or runs a display list containing eval coords with no
2338 * vertex maps enabled, we have to either copy all non-eval
2339 * data to a new buffer, or find a way of working around
2340 * the eval data. I choose the second option.
2342 * KW: This code not reached by cva - use IM to access storage.
2344 void gl_eval_vb( struct vertex_buffer
*VB
)
2346 struct immediate
*IM
= VB
->IM
;
2347 GLcontext
*ctx
= VB
->ctx
;
2348 GLuint req
= ctx
->CVA
.elt
.inputs
;
2349 GLfloat (*coord
)[4] = VB
->ObjPtr
->data
;
2350 GLuint
*flags
= VB
->Flag
;
2351 GLuint new_flags
= 0;
2354 GLuint any_eval1
= VB
->OrFlag
& (VERT_EVAL_C1
|VERT_EVAL_P1
);
2355 GLuint any_eval2
= VB
->OrFlag
& (VERT_EVAL_C2
|VERT_EVAL_P2
);
2356 GLuint all_eval
= VB
->AndFlag
& VERT_EVAL_ANY
;
2358 /* Handle the degenerate cases.
2360 if (any_eval1
&& !ctx
->Eval
.Map1Vertex4
&& !ctx
->Eval
.Map1Vertex3
) {
2361 VB
->PurgeFlags
|= (VERT_EVAL_C1
|VERT_EVAL_P1
);
2363 any_eval1
= GL_FALSE
;
2366 if (any_eval2
&& !ctx
->Eval
.Map2Vertex4
&& !ctx
->Eval
.Map2Vertex3
) {
2367 VB
->PurgeFlags
|= (VERT_EVAL_C2
|VERT_EVAL_P2
);
2369 any_eval2
= GL_FALSE
;
2372 /* KW: This really is a degenerate case - doing this disables
2373 * culling, and causes dummy values for the missing vertices to be
2374 * transformed and clip tested. It also forces the individual
2375 * cliptesting of each primitive in vb_render. I wish there was a
2376 * nice alternative, but I can't say I want to put effort into
2377 * optimizing such a bad usage of the library - I'd much rather
2378 * work on useful changes.
2380 if (VB
->PurgeFlags
) {
2381 if (!any_eval1
&& !any_eval2
&& all_eval
) VB
->Count
= VB_START
;
2382 gl_purge_vertices( VB
);
2383 if (!any_eval1
&& !any_eval2
) return;
2385 VB
->IndirectCount
= VB
->Count
;
2387 /* Translate points into coords.
2389 if (any_eval1
&& (VB
->OrFlag
& VERT_EVAL_P1
))
2391 eval_points1( IM
->Obj
, coord
, flags
,
2392 ctx
->Eval
.MapGrid1du
,
2393 ctx
->Eval
.MapGrid1u1
);
2398 if (any_eval2
&& (VB
->OrFlag
& VERT_EVAL_P2
))
2400 eval_points2( IM
->Obj
, coord
, flags
,
2401 ctx
->Eval
.MapGrid2du
,
2402 ctx
->Eval
.MapGrid2u1
,
2403 ctx
->Eval
.MapGrid2dv
,
2404 ctx
->Eval
.MapGrid2v1
);
2409 /* Perform the evaluations on active data elements.
2411 if (req
& VERT_INDEX
)
2413 GLvector1ui
*in_index
= VB
->IndexPtr
;
2414 GLvector1ui
*out_index
= &IM
->v
.Index
;
2416 if (ctx
->Eval
.Map1Index
&& any_eval1
)
2417 VB
->IndexPtr
= eval1_1ui( out_index
, coord
, flags
,
2418 &ctx
->EvalMap
.Map1Index
);
2420 if (ctx
->Eval
.Map2Index
&& any_eval2
)
2421 VB
->IndexPtr
= eval2_1ui( out_index
, coord
, flags
,
2422 &ctx
->EvalMap
.Map2Index
);
2424 if (VB
->IndexPtr
!= in_index
) {
2425 new_flags
|= VERT_INDEX
;
2427 VB
->IndexPtr
= copy_1ui( out_index
, in_index
, flags
);
2431 if (req
& VERT_RGBA
)
2433 GLvector4ub
*in_color
= VB
->ColorPtr
;
2434 GLvector4ub
*out_color
= &IM
->v
.Color
;
2436 if (ctx
->Eval
.Map1Color4
&& any_eval1
)
2437 VB
->ColorPtr
= eval1_color( out_color
, coord
, flags
,
2438 &ctx
->EvalMap
.Map1Color4
);
2440 if (ctx
->Eval
.Map2Color4
&& any_eval2
)
2441 VB
->ColorPtr
= eval2_color( out_color
, coord
, flags
,
2442 &ctx
->EvalMap
.Map2Color4
);
2444 if (VB
->ColorPtr
!= in_color
) {
2445 new_flags
|= VERT_RGBA
;
2447 VB
->ColorPtr
= copy_4ub( out_color
, in_color
, flags
);
2450 VB
->Color
[0] = VB
->Color
[1] = VB
->ColorPtr
;
2454 if (req
& VERT_NORM
)
2456 GLvector3f
*in_normal
= VB
->NormalPtr
;
2457 GLvector3f
*out_normal
= &IM
->v
.Normal
;
2459 if (ctx
->Eval
.Map1Normal
&& any_eval1
)
2460 VB
->NormalPtr
= eval1_norm( out_normal
, coord
, flags
,
2461 &ctx
->EvalMap
.Map1Normal
);
2463 if (ctx
->Eval
.Map2Normal
&& any_eval2
)
2464 VB
->NormalPtr
= eval2_norm( out_normal
, coord
, flags
,
2465 &ctx
->EvalMap
.Map2Normal
);
2467 if (VB
->NormalPtr
!= in_normal
) {
2468 new_flags
|= VERT_NORM
;
2470 VB
->NormalPtr
= copy_3f( out_normal
, in_normal
, flags
);
2475 if (req
& VERT_TEX_ANY(0))
2477 GLvector4f
*tc
= VB
->TexCoordPtr
[0];
2478 GLvector4f
*in
= tc
;
2479 GLvector4f
*out
= &IM
->v
.TexCoord
[0];
2482 if (ctx
->Eval
.Map1TextureCoord4
)
2483 tc
= eval1_4f( out
, coord
, flags
, 4, &ctx
->EvalMap
.Map1Texture4
);
2484 else if (ctx
->Eval
.Map1TextureCoord3
)
2485 tc
= eval1_4f( out
, coord
, flags
, 3, &ctx
->EvalMap
.Map1Texture3
);
2486 else if (ctx
->Eval
.Map1TextureCoord2
)
2487 tc
= eval1_4f( out
, coord
, flags
, 2, &ctx
->EvalMap
.Map1Texture2
);
2488 else if (ctx
->Eval
.Map1TextureCoord1
)
2489 tc
= eval1_4f( out
, coord
, flags
, 1, &ctx
->EvalMap
.Map1Texture1
);
2493 if (ctx
->Eval
.Map2TextureCoord4
)
2494 tc
= eval2_4f( out
, coord
, flags
, 4, &ctx
->EvalMap
.Map2Texture4
);
2495 else if (ctx
->Eval
.Map2TextureCoord3
)
2496 tc
= eval2_4f( out
, coord
, flags
, 3, &ctx
->EvalMap
.Map2Texture3
);
2497 else if (ctx
->Eval
.Map2TextureCoord2
)
2498 tc
= eval2_4f( out
, coord
, flags
, 2, &ctx
->EvalMap
.Map2Texture2
);
2499 else if (ctx
->Eval
.Map2TextureCoord1
)
2500 tc
= eval2_4f( out
, coord
, flags
, 1, &ctx
->EvalMap
.Map2Texture1
);
2504 new_flags
|= VERT_TEX_ANY(0); /* fix for sizes.. */
2506 tc
= copy_4f( out
, in
, flags
);
2509 VB
->TexCoordPtr
[0] = tc
;
2514 GLvector4f
*in
= VB
->ObjPtr
;
2515 GLvector4f
*out
= &IM
->v
.Obj
;
2516 GLvector4f
*obj
= in
;
2519 if (ctx
->Eval
.Map1Vertex4
)
2520 obj
= eval1_4f( out
, coord
, flags
, 4, &ctx
->EvalMap
.Map1Vertex4
);
2522 obj
= eval1_4f( out
, coord
, flags
, 3, &ctx
->EvalMap
.Map1Vertex3
);
2526 if (ctx
->Eval
.Map2Vertex4
)
2528 if (ctx
->Eval
.AutoNormal
&& (req
& VERT_NORM
))
2529 obj
= eval2_obj_norm( out
, VB
->NormalPtr
, coord
, flags
, 4,
2530 &ctx
->EvalMap
.Map2Vertex4
);
2532 obj
= eval2_4f( out
, coord
, flags
, 4,
2533 &ctx
->EvalMap
.Map2Vertex4
);
2535 else if (ctx
->Eval
.Map2Vertex3
)
2537 if (ctx
->Eval
.AutoNormal
&& (req
& VERT_NORM
))
2538 obj
= eval2_obj_norm( out
, VB
->NormalPtr
, coord
, flags
, 3,
2539 &ctx
->EvalMap
.Map2Vertex3
);
2541 obj
= eval2_4f( out
, coord
, flags
, 3,
2542 &ctx
->EvalMap
.Map2Vertex3
);
2546 if (obj
!= in
&& !all_eval
)
2547 obj
= copy_4f( out
, in
, flags
);
2553 GLuint
*oldflags
= VB
->Flag
;
2554 GLuint
*flags
= VB
->Flag
= VB
->EvaluatedFlags
;
2556 GLuint count
= VB
->Count
;
2559 VB
->EvaluatedFlags
= (GLuint
*)malloc(VB
->Size
* sizeof(GLuint
));
2560 flags
= VB
->Flag
= VB
->EvaluatedFlags
;
2564 for (i
= 0 ; i
< count
; i
++)
2565 flags
[i
] = oldflags
[i
] | new_flags
;
2566 VB
->AndFlag
|= new_flags
;
2568 GLuint andflag
= ~0;
2569 for (i
= 0 ; i
< count
; i
++) {
2570 if (oldflags
[i
] & VERT_EVAL_ANY
)
2571 flags
[i
] = oldflags
[i
] | new_flags
;
2572 andflag
&= flags
[i
];
2574 VB
->AndFlag
= andflag
;
2580 void gl_MapGrid1f( GLcontext
* ctx
, GLint un
, GLfloat u1
, GLfloat u2
)
2582 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glMapGrid1f");
2585 gl_error( ctx
, GL_INVALID_VALUE
, "glMapGrid1f" );
2588 ctx
->Eval
.MapGrid1un
= un
;
2589 ctx
->Eval
.MapGrid1u1
= u1
;
2590 ctx
->Eval
.MapGrid1u2
= u2
;
2591 ctx
->Eval
.MapGrid1du
= (u2
- u1
) / (GLfloat
) un
;
2595 void gl_MapGrid2f( GLcontext
* ctx
, GLint un
, GLfloat u1
, GLfloat u2
,
2596 GLint vn
, GLfloat v1
, GLfloat v2
)
2598 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glMapGrid2f");
2600 gl_error( ctx
, GL_INVALID_VALUE
, "glMapGrid2f(un)" );
2604 gl_error( ctx
, GL_INVALID_VALUE
, "glMapGrid2f(vn)" );
2607 ctx
->Eval
.MapGrid2un
= un
;
2608 ctx
->Eval
.MapGrid2u1
= u1
;
2609 ctx
->Eval
.MapGrid2u2
= u2
;
2610 ctx
->Eval
.MapGrid2du
= (u2
- u1
) / (GLfloat
) un
;
2611 ctx
->Eval
.MapGrid2vn
= vn
;
2612 ctx
->Eval
.MapGrid2v1
= v1
;
2613 ctx
->Eval
.MapGrid2v2
= v2
;
2614 ctx
->Eval
.MapGrid2dv
= (v2
- v1
) / (GLfloat
) vn
;
2619 void gl_EvalMesh1( GLcontext
* ctx
, GLenum mode
, GLint i1
, GLint i2
)
2625 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glEvalMesh1");
2632 prim
= GL_LINE_STRIP
;
2635 gl_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh1(mode)" );
2639 /* No effect if vertex maps disabled.
2641 if (!ctx
->Eval
.Map1Vertex4
&& !ctx
->Eval
.Map1Vertex3
)
2644 du
= ctx
->Eval
.MapGrid1du
;
2645 u
= ctx
->Eval
.MapGrid1u1
+ i1
* du
;
2647 /* KW: Could short-circuit this to avoid the immediate mechanism.
2649 RESET_IMMEDIATE(ctx
);
2651 gl_Begin( ctx
, prim
);
2652 for (i
=i1
;i
<=i2
;i
++,u
+=du
) {
2653 gl_EvalCoord1f( ctx
, u
);
2660 void gl_EvalMesh2( GLcontext
* ctx
,
2663 GLint j1
, GLint j2
)
2666 GLfloat u
, du
, v
, dv
, v1
, u1
;
2668 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glEvalMesh2");
2670 /* No effect if vertex maps disabled.
2672 if (!ctx
->Eval
.Map2Vertex4
&& !ctx
->Eval
.Map2Vertex3
)
2675 du
= ctx
->Eval
.MapGrid2du
;
2676 dv
= ctx
->Eval
.MapGrid2dv
;
2677 v1
= ctx
->Eval
.MapGrid2v1
+ j1
* dv
;
2678 u1
= ctx
->Eval
.MapGrid2u1
+ i1
* du
;
2680 RESET_IMMEDIATE(ctx
);
2684 gl_Begin( ctx
, GL_POINTS
);
2685 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
2686 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
2687 gl_EvalCoord2f( ctx
, u
, v
);
2693 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
2694 gl_Begin( ctx
, GL_LINE_STRIP
);
2695 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
2696 gl_EvalCoord2f( ctx
, u
, v
);
2700 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
2701 gl_Begin( ctx
, GL_LINE_STRIP
);
2702 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
2703 gl_EvalCoord2f( ctx
, u
, v
);
2709 for (v
=v1
,j
=j1
;j
<j2
;j
++,v
+=dv
) {
2710 /* NOTE: a quad strip can't be used because the four */
2711 /* can't be guaranteed to be coplanar! */
2712 gl_Begin( ctx
, GL_TRIANGLE_STRIP
);
2713 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
2714 gl_EvalCoord2f( ctx
, u
, v
);
2715 gl_EvalCoord2f( ctx
, u
, v
+dv
);
2721 gl_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh2(mode)" );