projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed includes & added a few hooks for the DRI.
[mesa.git] / src / mesa / main / eval.c
1 /* $Id: eval.c,v 1.2 1999/10/08 09:27:10 keithw Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.1
6 *
7 * Copyright (C) 1999 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28
29
30
31 /*
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).
35 *
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.
39 *
40 * Thanks guys!
41 */
42
43
44 #ifdef PC_HEADER
45 #include "all.h"
46 #else
47 #ifndef XFree86Server
48 #include <math.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #else
52 #include "GL/xf86glx.h"
53 #endif
54 #include "context.h"
55 #include "eval.h"
56 #include "macros.h"
57 #include "mmath.h"
58 #include "types.h"
59 #include "vbcull.h"
60 #include "vbfill.h"
61 #include "vbxform.h"
62 #ifdef XFree86Server
63 #include "GL/xf86glx.h"
64 #endif
65 #endif
66
67
68 static GLfloat inv_tab[MAX_EVAL_ORDER];
69
70 /*
71 * Do one-time initialization for evaluators.
72 */
73 void gl_init_eval( void )
74 {
75 static int init_flag = 0;
76 GLuint i;
77
78 /* Compute a table of nCr (combination) values used by the
79 * Bernstein polynomial generator.
80 */
81
82 /* KW: precompute 1/x for useful x.
83 */
84 if (init_flag==0)
85 {
86 for (i = 1 ; i < MAX_EVAL_ORDER ; i++)
87 inv_tab[i] = 1.0 / i;
88 }
89
90 init_flag = 1;
91 }
92
93
94
95 /*
96 * Horner scheme for Bezier curves
97 *
98 * Bezier curves can be computed via a Horner scheme.
99 * Horner is numerically less stable than the de Casteljau
100 * algorithm, but it is faster. For curves of degree n
101 * the complexity of Horner is O(n) and de Casteljau is O(n^2).
102 * Since stability is not important for displaying curve
103 * points I decided to use the Horner scheme.
104 *
105 * A cubic Bezier curve with control points b0, b1, b2, b3 can be
106 * written as
107 *
108 * (([3] [3] ) [3] ) [3]
109 * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
110 *
111 * [n]
112 * where s=1-t and the binomial coefficients [i]. These can
113 * be computed iteratively using the identity:
114 *
115 * [n] [n ] [n]
116 * [i] = (n-i+1)/i * [i-1] and [0] = 1
117 */
118
119
120 static void
121 horner_bezier_curve(const GLfloat *cp, GLfloat *out, GLfloat t,
122 GLuint dim, GLuint order)
123 {
124 GLfloat s, powert;
125 GLuint i, k, bincoeff;
126
127 if(order >= 2)
128 {
129 bincoeff = order-1;
130 s = 1.0-t;
131
132 for(k=0; k<dim; k++)
133 out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
134
135 for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
136 {
137 bincoeff *= order-i;
138 bincoeff *= inv_tab[i];
139
140 for(k=0; k<dim; k++)
141 out[k] = s*out[k] + bincoeff*powert*cp[k];
142 }
143 }
144 else /* order=1 -> constant curve */
145 {
146 for(k=0; k<dim; k++)
147 out[k] = cp[k];
148 }
149 }
150
151 /*
152 * Tensor product Bezier surfaces
153 *
154 * Again the Horner scheme is used to compute a point on a
155 * TP Bezier surface. First a control polygon for a curve
156 * on the surface in one parameter direction is computed,
157 * then the point on the curve for the other parameter
158 * direction is evaluated.
159 *
160 * To store the curve control polygon additional storage
161 * for max(uorder,vorder) points is needed in the
162 * control net cn.
163 */
164
165 static void
166 horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
167 GLuint dim, GLuint uorder, GLuint vorder)
168 {
169 GLfloat *cp = cn + uorder*vorder*dim;
170 GLuint i, uinc = vorder*dim;
171
172 if(vorder > uorder)
173 {
174 if(uorder >= 2)
175 {
176 GLfloat s, poweru;
177 GLuint j, k, bincoeff;
178
179 /* Compute the control polygon for the surface-curve in u-direction */
180 for(j=0; j<vorder; j++)
181 {
182 GLfloat *ucp = &cn[j*dim];
183
184 /* Each control point is the point for parameter u on a */
185 /* curve defined by the control polygons in u-direction */
186 bincoeff = uorder-1;
187 s = 1.0-u;
188
189 for(k=0; k<dim; k++)
190 cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
191
192 for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder;
193 i++, poweru*=u, ucp +=uinc)
194 {
195 bincoeff *= uorder-i;
196 bincoeff *= inv_tab[i];
197
198 for(k=0; k<dim; k++)
199 cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
200 }
201 }
202
203 /* Evaluate curve point in v */
204 horner_bezier_curve(cp, out, v, dim, vorder);
205 }
206 else /* uorder=1 -> cn defines a curve in v */
207 horner_bezier_curve(cn, out, v, dim, vorder);
208 }
209 else /* vorder <= uorder */
210 {
211 if(vorder > 1)
212 {
213 GLuint i;
214
215 /* Compute the control polygon for the surface-curve in u-direction */
216 for(i=0; i<uorder; i++, cn += uinc)
217 {
218 /* For constant i all cn[i][j] (j=0..vorder) are located */
219 /* on consecutive memory locations, so we can use */
220 /* horner_bezier_curve to compute the control points */
221
222 horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
223 }
224
225 /* Evaluate curve point in u */
226 horner_bezier_curve(cp, out, u, dim, uorder);
227 }
228 else /* vorder=1 -> cn defines a curve in u */
229 horner_bezier_curve(cn, out, u, dim, uorder);
230 }
231 }
232
233 /*
234 * The direct de Casteljau algorithm is used when a point on the
235 * surface and the tangent directions spanning the tangent plane
236 * should be computed (this is needed to compute normals to the
237 * surface). In this case the de Casteljau algorithm approach is
238 * nicer because a point and the partial derivatives can be computed
239 * at the same time. To get the correct tangent length du and dv
240 * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1.
241 * Since only the directions are needed, this scaling step is omitted.
242 *
243 * De Casteljau needs additional storage for uorder*vorder
244 * values in the control net cn.
245 */
246
247 static void
248 de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
249 GLfloat u, GLfloat v, GLuint dim,
250 GLuint uorder, GLuint vorder)
251 {
252 GLfloat *dcn = cn + uorder*vorder*dim;
253 GLfloat us = 1.0-u, vs = 1.0-v;
254 GLuint h, i, j, k;
255 GLuint minorder = uorder < vorder ? uorder : vorder;
256 GLuint uinc = vorder*dim;
257 GLuint dcuinc = vorder;
258
259 /* Each component is evaluated separately to save buffer space */
260 /* This does not drasticaly decrease the performance of the */
261 /* algorithm. If additional storage for (uorder-1)*(vorder-1) */
262 /* points would be available, the components could be accessed */
263 /* in the innermost loop which could lead to less cache misses. */
264
265 #define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)]
266 #define DCN(I, J) dcn[(I)*dcuinc+(J)]
267 if(minorder < 3)
268 {
269 if(uorder==vorder)
270 {
271 for(k=0; k<dim; k++)
272 {
273 /* Derivative direction in u */
274 du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
275 v*(CN(1,1,k) - CN(0,1,k));
276
277 /* Derivative direction in v */
278 dv[k] = us*(CN(0,1,k) - CN(0,0,k)) +
279 u*(CN(1,1,k) - CN(1,0,k));
280
281 /* bilinear de Casteljau step */
282 out[k] = us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
283 u*(vs*CN(1,0,k) + v*CN(1,1,k));
284 }
285 }
286 else if(minorder == uorder)
287 {
288 for(k=0; k<dim; k++)
289 {
290 /* bilinear de Casteljau step */
291 DCN(1,0) = CN(1,0,k) - CN(0,0,k);
292 DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
293
294 for(j=0; j<vorder-1; j++)
295 {
296 /* for the derivative in u */
297 DCN(1,j+1) = CN(1,j+1,k) - CN(0,j+1,k);
298 DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
299
300 /* for the `point' */
301 DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
302 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
303 }
304
305 /* remaining linear de Casteljau steps until the second last step */
306 for(h=minorder; h<vorder-1; h++)
307 for(j=0; j<vorder-h; j++)
308 {
309 /* for the derivative in u */
310 DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
311
312 /* for the `point' */
313 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
314 }
315
316 /* derivative direction in v */
317 dv[k] = DCN(0,1) - DCN(0,0);
318
319 /* derivative direction in u */
320 du[k] = vs*DCN(1,0) + v*DCN(1,1);
321
322 /* last linear de Casteljau step */
323 out[k] = vs*DCN(0,0) + v*DCN(0,1);
324 }
325 }
326 else /* minorder == vorder */
327 {
328 for(k=0; k<dim; k++)
329 {
330 /* bilinear de Casteljau step */
331 DCN(0,1) = CN(0,1,k) - CN(0,0,k);
332 DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
333 for(i=0; i<uorder-1; i++)
334 {
335 /* for the derivative in v */
336 DCN(i+1,1) = CN(i+1,1,k) - CN(i+1,0,k);
337 DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
338
339 /* for the `point' */
340 DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
341 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
342 }
343
344 /* remaining linear de Casteljau steps until the second last step */
345 for(h=minorder; h<uorder-1; h++)
346 for(i=0; i<uorder-h; i++)
347 {
348 /* for the derivative in v */
349 DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
350
351 /* for the `point' */
352 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
353 }
354
355 /* derivative direction in u */
356 du[k] = DCN(1,0) - DCN(0,0);
357
358 /* derivative direction in v */
359 dv[k] = us*DCN(0,1) + u*DCN(1,1);
360
361 /* last linear de Casteljau step */
362 out[k] = us*DCN(0,0) + u*DCN(1,0);
363 }
364 }
365 }
366 else if(uorder == vorder)
367 {
368 for(k=0; k<dim; k++)
369 {
370 /* first bilinear de Casteljau step */
371 for(i=0; i<uorder-1; i++)
372 {
373 DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
374 for(j=0; j<vorder-1; j++)
375 {
376 DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
377 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
378 }
379 }
380
381 /* remaining bilinear de Casteljau steps until the second last step */
382 for(h=2; h<minorder-1; h++)
383 for(i=0; i<uorder-h; i++)
384 {
385 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
386 for(j=0; j<vorder-h; j++)
387 {
388 DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
389 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
390 }
391 }
392
393 /* derivative direction in u */
394 du[k] = vs*(DCN(1,0) - DCN(0,0)) +
395 v*(DCN(1,1) - DCN(0,1));
396
397 /* derivative direction in v */
398 dv[k] = us*(DCN(0,1) - DCN(0,0)) +
399 u*(DCN(1,1) - DCN(1,0));
400
401 /* last bilinear de Casteljau step */
402 out[k] = us*(vs*DCN(0,0) + v*DCN(0,1)) +
403 u*(vs*DCN(1,0) + v*DCN(1,1));
404 }
405 }
406 else if(minorder == uorder)
407 {
408 for(k=0; k<dim; k++)
409 {
410 /* first bilinear de Casteljau step */
411 for(i=0; i<uorder-1; i++)
412 {
413 DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
414 for(j=0; j<vorder-1; j++)
415 {
416 DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
417 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
418 }
419 }
420
421 /* remaining bilinear de Casteljau steps until the second last step */
422 for(h=2; h<minorder-1; h++)
423 for(i=0; i<uorder-h; i++)
424 {
425 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
426 for(j=0; j<vorder-h; j++)
427 {
428 DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
429 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
430 }
431 }
432
433 /* last bilinear de Casteljau step */
434 DCN(2,0) = DCN(1,0) - DCN(0,0);
435 DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
436 for(j=0; j<vorder-1; j++)
437 {
438 /* for the derivative in u */
439 DCN(2,j+1) = DCN(1,j+1) - DCN(0,j+1);
440 DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
441
442 /* for the `point' */
443 DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
444 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
445 }
446
447 /* remaining linear de Casteljau steps until the second last step */
448 for(h=minorder; h<vorder-1; h++)
449 for(j=0; j<vorder-h; j++)
450 {
451 /* for the derivative in u */
452 DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
453
454 /* for the `point' */
455 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
456 }
457
458 /* derivative direction in v */
459 dv[k] = DCN(0,1) - DCN(0,0);
460
461 /* derivative direction in u */
462 du[k] = vs*DCN(2,0) + v*DCN(2,1);
463
464 /* last linear de Casteljau step */
465 out[k] = vs*DCN(0,0) + v*DCN(0,1);
466 }
467 }
468 else /* minorder == vorder */
469 {
470 for(k=0; k<dim; k++)
471 {
472 /* first bilinear de Casteljau step */
473 for(i=0; i<uorder-1; i++)
474 {
475 DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
476 for(j=0; j<vorder-1; j++)
477 {
478 DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
479 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
480 }
481 }
482
483 /* remaining bilinear de Casteljau steps until the second last step */
484 for(h=2; h<minorder-1; h++)
485 for(i=0; i<uorder-h; i++)
486 {
487 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
488 for(j=0; j<vorder-h; j++)
489 {
490 DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
491 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
492 }
493 }
494
495 /* last bilinear de Casteljau step */
496 DCN(0,2) = DCN(0,1) - DCN(0,0);
497 DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
498 for(i=0; i<uorder-1; i++)
499 {
500 /* for the derivative in v */
501 DCN(i+1,2) = DCN(i+1,1) - DCN(i+1,0);
502 DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
503
504 /* for the `point' */
505 DCN(i+1,0) = vs*DCN(i+1,0) + v*DCN(i+1,1);
506 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
507 }
508
509 /* remaining linear de Casteljau steps until the second last step */
510 for(h=minorder; h<uorder-1; h++)
511 for(i=0; i<uorder-h; i++)
512 {
513 /* for the derivative in v */
514 DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
515
516 /* for the `point' */
517 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
518 }
519
520 /* derivative direction in u */
521 du[k] = DCN(1,0) - DCN(0,0);
522
523 /* derivative direction in v */
524 dv[k] = us*DCN(0,2) + u*DCN(1,2);
525
526 /* last linear de Casteljau step */
527 out[k] = us*DCN(0,0) + u*DCN(1,0);
528 }
529 }
530 #undef DCN
531 #undef CN
532 }
533
534 /*
535 * Return the number of components per control point for any type of
536 * evaluator. Return 0 if bad target.
537 */
538
539 static GLint components( GLenum target )
540 {
541 switch (target) {
542 case GL_MAP1_VERTEX_3: return 3;
543 case GL_MAP1_VERTEX_4: return 4;
544 case GL_MAP1_INDEX: return 1;
545 case GL_MAP1_COLOR_4: return 4;
546 case GL_MAP1_NORMAL: return 3;
547 case GL_MAP1_TEXTURE_COORD_1: return 1;
548 case GL_MAP1_TEXTURE_COORD_2: return 2;
549 case GL_MAP1_TEXTURE_COORD_3: return 3;
550 case GL_MAP1_TEXTURE_COORD_4: return 4;
551 case GL_MAP2_VERTEX_3: return 3;
552 case GL_MAP2_VERTEX_4: return 4;
553 case GL_MAP2_INDEX: return 1;
554 case GL_MAP2_COLOR_4: return 4;
555 case GL_MAP2_NORMAL: return 3;
556 case GL_MAP2_TEXTURE_COORD_1: return 1;
557 case GL_MAP2_TEXTURE_COORD_2: return 2;
558 case GL_MAP2_TEXTURE_COORD_3: return 3;
559 case GL_MAP2_TEXTURE_COORD_4: return 4;
560 default: return 0;
561 }
562 }
563
564
565 /**********************************************************************/
566 /*** Copy and deallocate control points ***/
567 /**********************************************************************/
568
569
570 /*
571 * Copy 1-parametric evaluator control points from user-specified
572 * memory space to a buffer of contiguous control points.
573 * Input: see glMap1f for details
574 * Return: pointer to buffer of contiguous control points or NULL if out
575 * of memory.
576 */
577 GLfloat *gl_copy_map_points1f( GLenum target,
578 GLint ustride, GLint uorder,
579 const GLfloat *points )
580 {
581 GLfloat *buffer, *p;
582 GLint i, k, size = components(target);
583
584 if (!points || size==0) {
585 return NULL;
586 }
587
588 buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
589
590 if(buffer)
591 for(i=0, p=buffer; i<uorder; i++, points+=ustride)
592 for(k=0; k<size; k++)
593 *p++ = points[k];
594
595 return buffer;
596 }
597
598
599
600 /*
601 * Same as above but convert doubles to floats.
602 */
603 GLfloat *gl_copy_map_points1d( GLenum target,
604 GLint ustride, GLint uorder,
605 const GLdouble *points )
606 {
607 GLfloat *buffer, *p;
608 GLint i, k, size = components(target);
609
610 if (!points || size==0) {
611 return NULL;
612 }
613
614 buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
615
616 if(buffer)
617 for(i=0, p=buffer; i<uorder; i++, points+=ustride)
618 for(k=0; k<size; k++)
619 *p++ = (GLfloat) points[k];
620
621 return buffer;
622 }
623
624
625
626 /*
627 * Copy 2-parametric evaluator control points from user-specified
628 * memory space to a buffer of contiguous control points.
629 * Additional memory is allocated to be used by the horner and
630 * de Casteljau evaluation schemes.
631 *
632 * Input: see glMap2f for details
633 * Return: pointer to buffer of contiguous control points or NULL if out
634 * of memory.
635 */
636 GLfloat *gl_copy_map_points2f( GLenum target,
637 GLint ustride, GLint uorder,
638 GLint vstride, GLint vorder,
639 const GLfloat *points )
640 {
641 GLfloat *buffer, *p;
642 GLint i, j, k, size, dsize, hsize;
643 GLint uinc;
644
645 size = components(target);
646
647 if (!points || size==0) {
648 return NULL;
649 }
650
651 /* max(uorder, vorder) additional points are used in */
652 /* horner evaluation and uorder*vorder additional */
653 /* values are needed for de Casteljau */
654 dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
655 hsize = (uorder > vorder ? uorder : vorder)*size;
656
657 if(hsize>dsize)
658 buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
659 else
660 buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
661
662 /* compute the increment value for the u-loop */
663 uinc = ustride - vorder*vstride;
664
665 if (buffer)
666 for (i=0, p=buffer; i<uorder; i++, points += uinc)
667 for (j=0; j<vorder; j++, points += vstride)
668 for (k=0; k<size; k++)
669 *p++ = points[k];
670
671 return buffer;
672 }
673
674
675
676 /*
677 * Same as above but convert doubles to floats.
678 */
679 GLfloat *gl_copy_map_points2d(GLenum target,
680 GLint ustride, GLint uorder,
681 GLint vstride, GLint vorder,
682 const GLdouble *points )
683 {
684 GLfloat *buffer, *p;
685 GLint i, j, k, size, hsize, dsize;
686 GLint uinc;
687
688 size = components(target);
689
690 if (!points || size==0) {
691 return NULL;
692 }
693
694 /* max(uorder, vorder) additional points are used in */
695 /* horner evaluation and uorder*vorder additional */
696 /* values are needed for de Casteljau */
697 dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
698 hsize = (uorder > vorder ? uorder : vorder)*size;
699
700 if(hsize>dsize)
701 buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
702 else
703 buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
704
705 /* compute the increment value for the u-loop */
706 uinc = ustride - vorder*vstride;
707
708 if (buffer)
709 for (i=0, p=buffer; i<uorder; i++, points += uinc)
710 for (j=0; j<vorder; j++, points += vstride)
711 for (k=0; k<size; k++)
712 *p++ = (GLfloat) points[k];
713
714 return buffer;
715 }
716
717
718 /*
719 * This function is called by the display list deallocator function to
720 * specify that a given set of control points are no longer needed.
721 */
722 void gl_free_control_points( GLcontext* ctx, GLenum target, GLfloat *data )
723 {
724 struct gl_1d_map *map1 = NULL;
725 struct gl_2d_map *map2 = NULL;
726
727 switch (target) {
728 case GL_MAP1_VERTEX_3:
729 map1 = &ctx->EvalMap.Map1Vertex3;
730 break;
731 case GL_MAP1_VERTEX_4:
732 map1 = &ctx->EvalMap.Map1Vertex4;
733 break;
734 case GL_MAP1_INDEX:
735 map1 = &ctx->EvalMap.Map1Index;
736 break;
737 case GL_MAP1_COLOR_4:
738 map1 = &ctx->EvalMap.Map1Color4;
739 break;
740 case GL_MAP1_NORMAL:
741 map1 = &ctx->EvalMap.Map1Normal;
742 break;
743 case GL_MAP1_TEXTURE_COORD_1:
744 map1 = &ctx->EvalMap.Map1Texture1;
745 break;
746 case GL_MAP1_TEXTURE_COORD_2:
747 map1 = &ctx->EvalMap.Map1Texture2;
748 break;
749 case GL_MAP1_TEXTURE_COORD_3:
750 map1 = &ctx->EvalMap.Map1Texture3;
751 break;
752 case GL_MAP1_TEXTURE_COORD_4:
753 map1 = &ctx->EvalMap.Map1Texture4;
754 break;
755 case GL_MAP2_VERTEX_3:
756 map2 = &ctx->EvalMap.Map2Vertex3;
757 break;
758 case GL_MAP2_VERTEX_4:
759 map2 = &ctx->EvalMap.Map2Vertex4;
760 break;
761 case GL_MAP2_INDEX:
762 map2 = &ctx->EvalMap.Map2Index;
763 break;
764 case GL_MAP2_COLOR_4:
765 map2 = &ctx->EvalMap.Map2Color4;
766 break;
767 case GL_MAP2_NORMAL:
768 map2 = &ctx->EvalMap.Map2Normal;
769 break;
770 case GL_MAP2_TEXTURE_COORD_1:
771 map2 = &ctx->EvalMap.Map2Texture1;
772 break;
773 case GL_MAP2_TEXTURE_COORD_2:
774 map2 = &ctx->EvalMap.Map2Texture2;
775 break;
776 case GL_MAP2_TEXTURE_COORD_3:
777 map2 = &ctx->EvalMap.Map2Texture3;
778 break;
779 case GL_MAP2_TEXTURE_COORD_4:
780 map2 = &ctx->EvalMap.Map2Texture4;
781 break;
782 default:
783 gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
784 return;
785 }
786
787 if (map1) {
788 if (data==map1->Points) {
789 /* The control points in the display list are currently */
790 /* being used so we can mark them as discard-able. */
791 map1->Retain = GL_FALSE;
792 }
793 else {
794 /* The control points in the display list are not currently */
795 /* being used. */
796 free( data );
797 }
798 }
799 if (map2) {
800 if (data==map2->Points) {
801 /* The control points in the display list are currently */
802 /* being used so we can mark them as discard-able. */
803 map2->Retain = GL_FALSE;
804 }
805 else {
806 /* The control points in the display list are not currently */
807 /* being used. */
808 free( data );
809 }
810 }
811
812 }
813
814
815
816 /**********************************************************************/
817 /*** API entry points ***/
818 /**********************************************************************/
819
820
821 /*
822 * Note that the array of control points must be 'unpacked' at this time.
823 * Input: retain - if TRUE, this control point data is also in a display
824 * list and can't be freed until the list is freed.
825 */
826 void gl_Map1f( GLcontext* ctx, GLenum target,
827 GLfloat u1, GLfloat u2, GLint stride,
828 GLint order, const GLfloat *points, GLboolean retain )
829 {
830 GLint k;
831
832 if (!points) {
833 gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
834 return;
835 }
836
837 /* may be a new stride after copying control points */
838 stride = components( target );
839
840 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMap1");
841
842 if (u1==u2) {
843 gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
844 return;
845 }
846
847 if (order<1 || order>MAX_EVAL_ORDER) {
848 gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
849 return;
850 }
851
852 k = components( target );
853 if (k==0) {
854 gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
855 }
856
857 if (stride < k) {
858 gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
859 return;
860 }
861
862 switch (target) {
863 case GL_MAP1_VERTEX_3:
864 ctx->EvalMap.Map1Vertex3.Order = order;
865 ctx->EvalMap.Map1Vertex3.u1 = u1;
866 ctx->EvalMap.Map1Vertex3.u2 = u2;
867 ctx->EvalMap.Map1Vertex3.du = 1.0 / (u2 - u1);
868 if (ctx->EvalMap.Map1Vertex3.Points
869 && !ctx->EvalMap.Map1Vertex3.Retain) {
870 free( ctx->EvalMap.Map1Vertex3.Points );
871 }
872 ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
873 ctx->EvalMap.Map1Vertex3.Retain = retain;
874 break;
875 case GL_MAP1_VERTEX_4:
876 ctx->EvalMap.Map1Vertex4.Order = order;
877 ctx->EvalMap.Map1Vertex4.u1 = u1;
878 ctx->EvalMap.Map1Vertex4.u2 = u2;
879 ctx->EvalMap.Map1Vertex4.du = 1.0 / (u2 - u1);
880 if (ctx->EvalMap.Map1Vertex4.Points
881 && !ctx->EvalMap.Map1Vertex4.Retain) {
882 free( ctx->EvalMap.Map1Vertex4.Points );
883 }
884 ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
885 ctx->EvalMap.Map1Vertex4.Retain = retain;
886 break;
887 case GL_MAP1_INDEX:
888 ctx->EvalMap.Map1Index.Order = order;
889 ctx->EvalMap.Map1Index.u1 = u1;
890 ctx->EvalMap.Map1Index.u2 = u2;
891 ctx->EvalMap.Map1Index.du = 1.0 / (u2 - u1);
892 if (ctx->EvalMap.Map1Index.Points
893 && !ctx->EvalMap.Map1Index.Retain) {
894 free( ctx->EvalMap.Map1Index.Points );
895 }
896 ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
897 ctx->EvalMap.Map1Index.Retain = retain;
898 break;
899 case GL_MAP1_COLOR_4:
900 ctx->EvalMap.Map1Color4.Order = order;
901 ctx->EvalMap.Map1Color4.u1 = u1;
902 ctx->EvalMap.Map1Color4.u2 = u2;
903 ctx->EvalMap.Map1Color4.du = 1.0 / (u2 - u1);
904 if (ctx->EvalMap.Map1Color4.Points
905 && !ctx->EvalMap.Map1Color4.Retain) {
906 free( ctx->EvalMap.Map1Color4.Points );
907 }
908 ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
909 ctx->EvalMap.Map1Color4.Retain = retain;
910 break;
911 case GL_MAP1_NORMAL:
912 ctx->EvalMap.Map1Normal.Order = order;
913 ctx->EvalMap.Map1Normal.u1 = u1;
914 ctx->EvalMap.Map1Normal.u2 = u2;
915 ctx->EvalMap.Map1Normal.du = 1.0 / (u2 - u1);
916 if (ctx->EvalMap.Map1Normal.Points
917 && !ctx->EvalMap.Map1Normal.Retain) {
918 free( ctx->EvalMap.Map1Normal.Points );
919 }
920 ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
921 ctx->EvalMap.Map1Normal.Retain = retain;
922 break;
923 case GL_MAP1_TEXTURE_COORD_1:
924 ctx->EvalMap.Map1Texture1.Order = order;
925 ctx->EvalMap.Map1Texture1.u1 = u1;
926 ctx->EvalMap.Map1Texture1.u2 = u2;
927 ctx->EvalMap.Map1Texture1.du = 1.0 / (u2 - u1);
928 if (ctx->EvalMap.Map1Texture1.Points
929 && !ctx->EvalMap.Map1Texture1.Retain) {
930 free( ctx->EvalMap.Map1Texture1.Points );
931 }
932 ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
933 ctx->EvalMap.Map1Texture1.Retain = retain;
934 break;
935 case GL_MAP1_TEXTURE_COORD_2:
936 ctx->EvalMap.Map1Texture2.Order = order;
937 ctx->EvalMap.Map1Texture2.u1 = u1;
938 ctx->EvalMap.Map1Texture2.u2 = u2;
939 ctx->EvalMap.Map1Texture2.du = 1.0 / (u2 - u1);
940 if (ctx->EvalMap.Map1Texture2.Points
941 && !ctx->EvalMap.Map1Texture2.Retain) {
942 free( ctx->EvalMap.Map1Texture2.Points );
943 }
944 ctx->EvalMap.Map1Texture2.Points = (GLfloat *) points;
945 ctx->EvalMap.Map1Texture2.Retain = retain;
946 break;
947 case GL_MAP1_TEXTURE_COORD_3:
948 ctx->EvalMap.Map1Texture3.Order = order;
949 ctx->EvalMap.Map1Texture3.u1 = u1;
950 ctx->EvalMap.Map1Texture3.u2 = u2;
951 ctx->EvalMap.Map1Texture3.du = 1.0 / (u2 - u1);
952 if (ctx->EvalMap.Map1Texture3.Points
953 && !ctx->EvalMap.Map1Texture3.Retain) {
954 free( ctx->EvalMap.Map1Texture3.Points );
955 }
956 ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
957 ctx->EvalMap.Map1Texture3.Retain = retain;
958 break;
959 case GL_MAP1_TEXTURE_COORD_4:
960 ctx->EvalMap.Map1Texture4.Order = order;
961 ctx->EvalMap.Map1Texture4.u1 = u1;
962 ctx->EvalMap.Map1Texture4.u2 = u2;
963 ctx->EvalMap.Map1Texture4.du = 1.0 / (u2 - u1);
964 if (ctx->EvalMap.Map1Texture4.Points
965 && !ctx->EvalMap.Map1Texture4.Retain) {
966 free( ctx->EvalMap.Map1Texture4.Points );
967 }
968 ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
969 ctx->EvalMap.Map1Texture4.Retain = retain;
970 break;
971 default:
972 gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
973 }
974 }
975
976
977
978
979 /*
980 * Note that the array of control points must be 'unpacked' at this time.
981 * Input: retain - if TRUE, this control point data is also in a display
982 * list and can't be freed until the list is freed.
983 */
984 void gl_Map2f( GLcontext* ctx, GLenum target,
985 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
986 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
987 const GLfloat *points, GLboolean retain )
988 {
989 GLint k;
990
991 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMap2");
992
993 if (u1==u2) {
994 gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
995 return;
996 }
997
998 if (v1==v2) {
999 gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
1000 return;
1001 }
1002
1003 if (uorder<1 || uorder>MAX_EVAL_ORDER) {
1004 gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
1005 return;
1006 }
1007
1008 if (vorder<1 || vorder>MAX_EVAL_ORDER) {
1009 gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
1010 return;
1011 }
1012
1013 k = components( target );
1014 if (k==0) {
1015 gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
1016 }
1017
1018 if (ustride < k) {
1019 gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
1020 return;
1021 }
1022 if (vstride < k) {
1023 gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
1024 return;
1025 }
1026
1027 switch (target) {
1028 case GL_MAP2_VERTEX_3:
1029 ctx->EvalMap.Map2Vertex3.Uorder = uorder;
1030 ctx->EvalMap.Map2Vertex3.u1 = u1;
1031 ctx->EvalMap.Map2Vertex3.u2 = u2;
1032 ctx->EvalMap.Map2Vertex3.du = 1.0 / (u2 - u1);
1033 ctx->EvalMap.Map2Vertex3.Vorder = vorder;
1034 ctx->EvalMap.Map2Vertex3.v1 = v1;
1035 ctx->EvalMap.Map2Vertex3.v2 = v2;
1036 ctx->EvalMap.Map2Vertex3.dv = 1.0 / (v2 - v1);
1037 if (ctx->EvalMap.Map2Vertex3.Points
1038 && !ctx->EvalMap.Map2Vertex3.Retain) {
1039 free( ctx->EvalMap.Map2Vertex3.Points );
1040 }
1041 ctx->EvalMap.Map2Vertex3.Retain = retain;
1042 ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
1043 break;
1044 case GL_MAP2_VERTEX_4:
1045 ctx->EvalMap.Map2Vertex4.Uorder = uorder;
1046 ctx->EvalMap.Map2Vertex4.u1 = u1;
1047 ctx->EvalMap.Map2Vertex4.u2 = u2;
1048 ctx->EvalMap.Map2Vertex4.du = 1.0 / (u2 - u1);
1049 ctx->EvalMap.Map2Vertex4.Vorder = vorder;
1050 ctx->EvalMap.Map2Vertex4.v1 = v1;
1051 ctx->EvalMap.Map2Vertex4.v2 = v2;
1052 ctx->EvalMap.Map2Vertex4.dv = 1.0 / (v2 - v1);
1053 if (ctx->EvalMap.Map2Vertex4.Points
1054 && !ctx->EvalMap.Map2Vertex4.Retain) {
1055 free( ctx->EvalMap.Map2Vertex4.Points );
1056 }
1057 ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
1058 ctx->EvalMap.Map2Vertex4.Retain = retain;
1059 break;
1060 case GL_MAP2_INDEX:
1061 ctx->EvalMap.Map2Index.Uorder = uorder;
1062 ctx->EvalMap.Map2Index.u1 = u1;
1063 ctx->EvalMap.Map2Index.u2 = u2;
1064 ctx->EvalMap.Map2Index.du = 1.0 / (u2 - u1);
1065 ctx->EvalMap.Map2Index.Vorder = vorder;
1066 ctx->EvalMap.Map2Index.v1 = v1;
1067 ctx->EvalMap.Map2Index.v2 = v2;
1068 ctx->EvalMap.Map2Index.dv = 1.0 / (v2 - v1);
1069 if (ctx->EvalMap.Map2Index.Points
1070 && !ctx->EvalMap.Map2Index.Retain) {
1071 free( ctx->EvalMap.Map2Index.Points );
1072 }
1073 ctx->EvalMap.Map2Index.Retain = retain;
1074 ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
1075 break;
1076 case GL_MAP2_COLOR_4:
1077 ctx->EvalMap.Map2Color4.Uorder = uorder;
1078 ctx->EvalMap.Map2Color4.u1 = u1;
1079 ctx->EvalMap.Map2Color4.u2 = u2;
1080 ctx->EvalMap.Map2Color4.du = 1.0 / (u2 - u1);
1081 ctx->EvalMap.Map2Color4.Vorder = vorder;
1082 ctx->EvalMap.Map2Color4.v1 = v1;
1083 ctx->EvalMap.Map2Color4.v2 = v2;
1084 ctx->EvalMap.Map2Color4.dv = 1.0 / (v2 - v1);
1085 if (ctx->EvalMap.Map2Color4.Points
1086 && !ctx->EvalMap.Map2Color4.Retain) {
1087 free( ctx->EvalMap.Map2Color4.Points );
1088 }
1089 ctx->EvalMap.Map2Color4.Retain = retain;
1090 ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
1091 break;
1092 case GL_MAP2_NORMAL:
1093 ctx->EvalMap.Map2Normal.Uorder = uorder;
1094 ctx->EvalMap.Map2Normal.u1 = u1;
1095 ctx->EvalMap.Map2Normal.u2 = u2;
1096 ctx->EvalMap.Map2Normal.du = 1.0 / (u2 - u1);
1097 ctx->EvalMap.Map2Normal.Vorder = vorder;
1098 ctx->EvalMap.Map2Normal.v1 = v1;
1099 ctx->EvalMap.Map2Normal.v2 = v2;
1100 ctx->EvalMap.Map2Normal.dv = 1.0 / (v2 - v1);
1101 if (ctx->EvalMap.Map2Normal.Points
1102 && !ctx->EvalMap.Map2Normal.Retain) {
1103 free( ctx->EvalMap.Map2Normal.Points );
1104 }
1105 ctx->EvalMap.Map2Normal.Retain = retain;
1106 ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
1107 break;
1108 case GL_MAP2_TEXTURE_COORD_1:
1109 ctx->EvalMap.Map2Texture1.Uorder = uorder;
1110 ctx->EvalMap.Map2Texture1.u1 = u1;
1111 ctx->EvalMap.Map2Texture1.u2 = u2;
1112 ctx->EvalMap.Map2Texture1.du = 1.0 / (u2 - u1);
1113 ctx->EvalMap.Map2Texture1.Vorder = vorder;
1114 ctx->EvalMap.Map2Texture1.v1 = v1;
1115 ctx->EvalMap.Map2Texture1.v2 = v2;
1116 ctx->EvalMap.Map2Texture1.dv = 1.0 / (v2 - v1);
1117 if (ctx->EvalMap.Map2Texture1.Points
1118 && !ctx->EvalMap.Map2Texture1.Retain) {
1119 free( ctx->EvalMap.Map2Texture1.Points );
1120 }
1121 ctx->EvalMap.Map2Texture1.Retain = retain;
1122 ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
1123 break;
1124 case GL_MAP2_TEXTURE_COORD_2:
1125 ctx->EvalMap.Map2Texture2.Uorder = uorder;
1126 ctx->EvalMap.Map2Texture2.u1 = u1;
1127 ctx->EvalMap.Map2Texture2.u2 = u2;
1128 ctx->EvalMap.Map2Texture2.du = 1.0 / (u2 - u1);
1129 ctx->EvalMap.Map2Texture2.Vorder = vorder;
1130 ctx->EvalMap.Map2Texture2.v1 = v1;
1131 ctx->EvalMap.Map2Texture2.v2 = v2;
1132 ctx->EvalMap.Map2Texture2.dv = 1.0 / (v2 - v1);
1133 if (ctx->EvalMap.Map2Texture2.Points
1134 && !ctx->EvalMap.Map2Texture2.Retain) {
1135 free( ctx->EvalMap.Map2Texture2.Points );
1136 }
1137 ctx->EvalMap.Map2Texture2.Retain = retain;
1138 ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
1139 break;
1140 case GL_MAP2_TEXTURE_COORD_3:
1141 ctx->EvalMap.Map2Texture3.Uorder = uorder;
1142 ctx->EvalMap.Map2Texture3.u1 = u1;
1143 ctx->EvalMap.Map2Texture3.u2 = u2;
1144 ctx->EvalMap.Map2Texture3.du = 1.0 / (u2 - u1);
1145 ctx->EvalMap.Map2Texture3.Vorder = vorder;
1146 ctx->EvalMap.Map2Texture3.v1 = v1;
1147 ctx->EvalMap.Map2Texture3.v2 = v2;
1148 ctx->EvalMap.Map2Texture3.dv = 1.0 / (v2 - v1);
1149 if (ctx->EvalMap.Map2Texture3.Points
1150 && !ctx->EvalMap.Map2Texture3.Retain) {
1151 free( ctx->EvalMap.Map2Texture3.Points );
1152 }
1153 ctx->EvalMap.Map2Texture3.Retain = retain;
1154 ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
1155 break;
1156 case GL_MAP2_TEXTURE_COORD_4:
1157 ctx->EvalMap.Map2Texture4.Uorder = uorder;
1158 ctx->EvalMap.Map2Texture4.u1 = u1;
1159 ctx->EvalMap.Map2Texture4.u2 = u2;
1160 ctx->EvalMap.Map2Texture4.du = 1.0 / (u2 - u1);
1161 ctx->EvalMap.Map2Texture4.Vorder = vorder;
1162 ctx->EvalMap.Map2Texture4.v1 = v1;
1163 ctx->EvalMap.Map2Texture4.v2 = v2;
1164 ctx->EvalMap.Map2Texture4.dv = 1.0 / (v2 - v1);
1165 if (ctx->EvalMap.Map2Texture4.Points
1166 && !ctx->EvalMap.Map2Texture4.Retain) {
1167 free( ctx->EvalMap.Map2Texture4.Points );
1168 }
1169 ctx->EvalMap.Map2Texture4.Retain = retain;
1170 ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
1171 break;
1172 default:
1173 gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
1174 }
1175 }
1176
1177
1178
1179
1180
1181 void gl_GetMapdv( GLcontext* ctx, GLenum target, GLenum query, GLdouble *v )
1182 {
1183 GLint i, n;
1184 GLfloat *data;
1185
1186 switch (query) {
1187 case GL_COEFF:
1188 switch (target) {
1189 case GL_MAP1_COLOR_4:
1190 data = ctx->EvalMap.Map1Color4.Points;
1191 n = ctx->EvalMap.Map1Color4.Order * 4;
1192 break;
1193 case GL_MAP1_INDEX:
1194 data = ctx->EvalMap.Map1Index.Points;
1195 n = ctx->EvalMap.Map1Index.Order;
1196 break;
1197 case GL_MAP1_NORMAL:
1198 data = ctx->EvalMap.Map1Normal.Points;
1199 n = ctx->EvalMap.Map1Normal.Order * 3;
1200 break;
1201 case GL_MAP1_TEXTURE_COORD_1:
1202 data = ctx->EvalMap.Map1Texture1.Points;
1203 n = ctx->EvalMap.Map1Texture1.Order * 1;
1204 break;
1205 case GL_MAP1_TEXTURE_COORD_2:
1206 data = ctx->EvalMap.Map1Texture2.Points;
1207 n = ctx->EvalMap.Map1Texture2.Order * 2;
1208 break;
1209 case GL_MAP1_TEXTURE_COORD_3:
1210 data = ctx->EvalMap.Map1Texture3.Points;
1211 n = ctx->EvalMap.Map1Texture3.Order * 3;
1212 break;
1213 case GL_MAP1_TEXTURE_COORD_4:
1214 data = ctx->EvalMap.Map1Texture4.Points;
1215 n = ctx->EvalMap.Map1Texture4.Order * 4;
1216 break;
1217 case GL_MAP1_VERTEX_3:
1218 data = ctx->EvalMap.Map1Vertex3.Points;
1219 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1220 break;
1221 case GL_MAP1_VERTEX_4:
1222 data = ctx->EvalMap.Map1Vertex4.Points;
1223 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1224 break;
1225 case GL_MAP2_COLOR_4:
1226 data = ctx->EvalMap.Map2Color4.Points;
1227 n = ctx->EvalMap.Map2Color4.Uorder
1228 * ctx->EvalMap.Map2Color4.Vorder * 4;
1229 break;
1230 case GL_MAP2_INDEX:
1231 data = ctx->EvalMap.Map2Index.Points;
1232 n = ctx->EvalMap.Map2Index.Uorder
1233 * ctx->EvalMap.Map2Index.Vorder;
1234 break;
1235 case GL_MAP2_NORMAL:
1236 data = ctx->EvalMap.Map2Normal.Points;
1237 n = ctx->EvalMap.Map2Normal.Uorder
1238 * ctx->EvalMap.Map2Normal.Vorder * 3;
1239 break;
1240 case GL_MAP2_TEXTURE_COORD_1:
1241 data = ctx->EvalMap.Map2Texture1.Points;
1242 n = ctx->EvalMap.Map2Texture1.Uorder
1243 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1244 break;
1245 case GL_MAP2_TEXTURE_COORD_2:
1246 data = ctx->EvalMap.Map2Texture2.Points;
1247 n = ctx->EvalMap.Map2Texture2.Uorder
1248 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1249 break;
1250 case GL_MAP2_TEXTURE_COORD_3:
1251 data = ctx->EvalMap.Map2Texture3.Points;
1252 n = ctx->EvalMap.Map2Texture3.Uorder
1253 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1254 break;
1255 case GL_MAP2_TEXTURE_COORD_4:
1256 data = ctx->EvalMap.Map2Texture4.Points;
1257 n = ctx->EvalMap.Map2Texture4.Uorder
1258 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1259 break;
1260 case GL_MAP2_VERTEX_3:
1261 data = ctx->EvalMap.Map2Vertex3.Points;
1262 n = ctx->EvalMap.Map2Vertex3.Uorder
1263 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1264 break;
1265 case GL_MAP2_VERTEX_4:
1266 data = ctx->EvalMap.Map2Vertex4.Points;
1267 n = ctx->EvalMap.Map2Vertex4.Uorder
1268 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1269 break;
1270 default:
1271 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1272 return;
1273 }
1274 if (data) {
1275 for (i=0;i<n;i++) {
1276 v[i] = data[i];
1277 }
1278 }
1279 break;
1280 case GL_ORDER:
1281 switch (target) {
1282 case GL_MAP1_COLOR_4:
1283 *v = ctx->EvalMap.Map1Color4.Order;
1284 break;
1285 case GL_MAP1_INDEX:
1286 *v = ctx->EvalMap.Map1Index.Order;
1287 break;
1288 case GL_MAP1_NORMAL:
1289 *v = ctx->EvalMap.Map1Normal.Order;
1290 break;
1291 case GL_MAP1_TEXTURE_COORD_1:
1292 *v = ctx->EvalMap.Map1Texture1.Order;
1293 break;
1294 case GL_MAP1_TEXTURE_COORD_2:
1295 *v = ctx->EvalMap.Map1Texture2.Order;
1296 break;
1297 case GL_MAP1_TEXTURE_COORD_3:
1298 *v = ctx->EvalMap.Map1Texture3.Order;
1299 break;
1300 case GL_MAP1_TEXTURE_COORD_4:
1301 *v = ctx->EvalMap.Map1Texture4.Order;
1302 break;
1303 case GL_MAP1_VERTEX_3:
1304 *v = ctx->EvalMap.Map1Vertex3.Order;
1305 break;
1306 case GL_MAP1_VERTEX_4:
1307 *v = ctx->EvalMap.Map1Vertex4.Order;
1308 break;
1309 case GL_MAP2_COLOR_4:
1310 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1311 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1312 break;
1313 case GL_MAP2_INDEX:
1314 v[0] = ctx->EvalMap.Map2Index.Uorder;
1315 v[1] = ctx->EvalMap.Map2Index.Vorder;
1316 break;
1317 case GL_MAP2_NORMAL:
1318 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1319 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1320 break;
1321 case GL_MAP2_TEXTURE_COORD_1:
1322 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1323 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1324 break;
1325 case GL_MAP2_TEXTURE_COORD_2:
1326 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1327 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1328 break;
1329 case GL_MAP2_TEXTURE_COORD_3:
1330 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1331 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1332 break;
1333 case GL_MAP2_TEXTURE_COORD_4:
1334 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1335 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1336 break;
1337 case GL_MAP2_VERTEX_3:
1338 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1339 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1340 break;
1341 case GL_MAP2_VERTEX_4:
1342 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1343 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1344 break;
1345 default:
1346 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1347 return;
1348 }
1349 break;
1350 case GL_DOMAIN:
1351 switch (target) {
1352 case GL_MAP1_COLOR_4:
1353 v[0] = ctx->EvalMap.Map1Color4.u1;
1354 v[1] = ctx->EvalMap.Map1Color4.u2;
1355 break;
1356 case GL_MAP1_INDEX:
1357 v[0] = ctx->EvalMap.Map1Index.u1;
1358 v[1] = ctx->EvalMap.Map1Index.u2;
1359 break;
1360 case GL_MAP1_NORMAL:
1361 v[0] = ctx->EvalMap.Map1Normal.u1;
1362 v[1] = ctx->EvalMap.Map1Normal.u2;
1363 break;
1364 case GL_MAP1_TEXTURE_COORD_1:
1365 v[0] = ctx->EvalMap.Map1Texture1.u1;
1366 v[1] = ctx->EvalMap.Map1Texture1.u2;
1367 break;
1368 case GL_MAP1_TEXTURE_COORD_2:
1369 v[0] = ctx->EvalMap.Map1Texture2.u1;
1370 v[1] = ctx->EvalMap.Map1Texture2.u2;
1371 break;
1372 case GL_MAP1_TEXTURE_COORD_3:
1373 v[0] = ctx->EvalMap.Map1Texture3.u1;
1374 v[1] = ctx->EvalMap.Map1Texture3.u2;
1375 break;
1376 case GL_MAP1_TEXTURE_COORD_4:
1377 v[0] = ctx->EvalMap.Map1Texture4.u1;
1378 v[1] = ctx->EvalMap.Map1Texture4.u2;
1379 break;
1380 case GL_MAP1_VERTEX_3:
1381 v[0] = ctx->EvalMap.Map1Vertex3.u1;
1382 v[1] = ctx->EvalMap.Map1Vertex3.u2;
1383 break;
1384 case GL_MAP1_VERTEX_4:
1385 v[0] = ctx->EvalMap.Map1Vertex4.u1;
1386 v[1] = ctx->EvalMap.Map1Vertex4.u2;
1387 break;
1388 case GL_MAP2_COLOR_4:
1389 v[0] = ctx->EvalMap.Map2Color4.u1;
1390 v[1] = ctx->EvalMap.Map2Color4.u2;
1391 v[2] = ctx->EvalMap.Map2Color4.v1;
1392 v[3] = ctx->EvalMap.Map2Color4.v2;
1393 break;
1394 case GL_MAP2_INDEX:
1395 v[0] = ctx->EvalMap.Map2Index.u1;
1396 v[1] = ctx->EvalMap.Map2Index.u2;
1397 v[2] = ctx->EvalMap.Map2Index.v1;
1398 v[3] = ctx->EvalMap.Map2Index.v2;
1399 break;
1400 case GL_MAP2_NORMAL:
1401 v[0] = ctx->EvalMap.Map2Normal.u1;
1402 v[1] = ctx->EvalMap.Map2Normal.u2;
1403 v[2] = ctx->EvalMap.Map2Normal.v1;
1404 v[3] = ctx->EvalMap.Map2Normal.v2;
1405 break;
1406 case GL_MAP2_TEXTURE_COORD_1:
1407 v[0] = ctx->EvalMap.Map2Texture1.u1;
1408 v[1] = ctx->EvalMap.Map2Texture1.u2;
1409 v[2] = ctx->EvalMap.Map2Texture1.v1;
1410 v[3] = ctx->EvalMap.Map2Texture1.v2;
1411 break;
1412 case GL_MAP2_TEXTURE_COORD_2:
1413 v[0] = ctx->EvalMap.Map2Texture2.u1;
1414 v[1] = ctx->EvalMap.Map2Texture2.u2;
1415 v[2] = ctx->EvalMap.Map2Texture2.v1;
1416 v[3] = ctx->EvalMap.Map2Texture2.v2;
1417 break;
1418 case GL_MAP2_TEXTURE_COORD_3:
1419 v[0] = ctx->EvalMap.Map2Texture3.u1;
1420 v[1] = ctx->EvalMap.Map2Texture3.u2;
1421 v[2] = ctx->EvalMap.Map2Texture3.v1;
1422 v[3] = ctx->EvalMap.Map2Texture3.v2;
1423 break;
1424 case GL_MAP2_TEXTURE_COORD_4:
1425 v[0] = ctx->EvalMap.Map2Texture4.u1;
1426 v[1] = ctx->EvalMap.Map2Texture4.u2;
1427 v[2] = ctx->EvalMap.Map2Texture4.v1;
1428 v[3] = ctx->EvalMap.Map2Texture4.v2;
1429 break;
1430 case GL_MAP2_VERTEX_3:
1431 v[0] = ctx->EvalMap.Map2Vertex3.u1;
1432 v[1] = ctx->EvalMap.Map2Vertex3.u2;
1433 v[2] = ctx->EvalMap.Map2Vertex3.v1;
1434 v[3] = ctx->EvalMap.Map2Vertex3.v2;
1435 break;
1436 case GL_MAP2_VERTEX_4:
1437 v[0] = ctx->EvalMap.Map2Vertex4.u1;
1438 v[1] = ctx->EvalMap.Map2Vertex4.u2;
1439 v[2] = ctx->EvalMap.Map2Vertex4.v1;
1440 v[3] = ctx->EvalMap.Map2Vertex4.v2;
1441 break;
1442 default:
1443 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1444 }
1445 break;
1446 default:
1447 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
1448 }
1449 }
1450
1451
1452 void gl_GetMapfv( GLcontext* ctx, GLenum target, GLenum query, GLfloat *v )
1453 {
1454 GLint i, n;
1455 GLfloat *data;
1456
1457 switch (query) {
1458 case GL_COEFF:
1459 switch (target) {
1460 case GL_MAP1_COLOR_4:
1461 data = ctx->EvalMap.Map1Color4.Points;
1462 n = ctx->EvalMap.Map1Color4.Order * 4;
1463 break;
1464 case GL_MAP1_INDEX:
1465 data = ctx->EvalMap.Map1Index.Points;
1466 n = ctx->EvalMap.Map1Index.Order;
1467 break;
1468 case GL_MAP1_NORMAL:
1469 data = ctx->EvalMap.Map1Normal.Points;
1470 n = ctx->EvalMap.Map1Normal.Order * 3;
1471 break;
1472 case GL_MAP1_TEXTURE_COORD_1:
1473 data = ctx->EvalMap.Map1Texture1.Points;
1474 n = ctx->EvalMap.Map1Texture1.Order * 1;
1475 break;
1476 case GL_MAP1_TEXTURE_COORD_2:
1477 data = ctx->EvalMap.Map1Texture2.Points;
1478 n = ctx->EvalMap.Map1Texture2.Order * 2;
1479 break;
1480 case GL_MAP1_TEXTURE_COORD_3:
1481 data = ctx->EvalMap.Map1Texture3.Points;
1482 n = ctx->EvalMap.Map1Texture3.Order * 3;
1483 break;
1484 case GL_MAP1_TEXTURE_COORD_4:
1485 data = ctx->EvalMap.Map1Texture4.Points;
1486 n = ctx->EvalMap.Map1Texture4.Order * 4;
1487 break;
1488 case GL_MAP1_VERTEX_3:
1489 data = ctx->EvalMap.Map1Vertex3.Points;
1490 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1491 break;
1492 case GL_MAP1_VERTEX_4:
1493 data = ctx->EvalMap.Map1Vertex4.Points;
1494 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1495 break;
1496 case GL_MAP2_COLOR_4:
1497 data = ctx->EvalMap.Map2Color4.Points;
1498 n = ctx->EvalMap.Map2Color4.Uorder
1499 * ctx->EvalMap.Map2Color4.Vorder * 4;
1500 break;
1501 case GL_MAP2_INDEX:
1502 data = ctx->EvalMap.Map2Index.Points;
1503 n = ctx->EvalMap.Map2Index.Uorder
1504 * ctx->EvalMap.Map2Index.Vorder;
1505 break;
1506 case GL_MAP2_NORMAL:
1507 data = ctx->EvalMap.Map2Normal.Points;
1508 n = ctx->EvalMap.Map2Normal.Uorder
1509 * ctx->EvalMap.Map2Normal.Vorder * 3;
1510 break;
1511 case GL_MAP2_TEXTURE_COORD_1:
1512 data = ctx->EvalMap.Map2Texture1.Points;
1513 n = ctx->EvalMap.Map2Texture1.Uorder
1514 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1515 break;
1516 case GL_MAP2_TEXTURE_COORD_2:
1517 data = ctx->EvalMap.Map2Texture2.Points;
1518 n = ctx->EvalMap.Map2Texture2.Uorder
1519 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1520 break;
1521 case GL_MAP2_TEXTURE_COORD_3:
1522 data = ctx->EvalMap.Map2Texture3.Points;
1523 n = ctx->EvalMap.Map2Texture3.Uorder
1524 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1525 break;
1526 case GL_MAP2_TEXTURE_COORD_4:
1527 data = ctx->EvalMap.Map2Texture4.Points;
1528 n = ctx->EvalMap.Map2Texture4.Uorder
1529 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1530 break;
1531 case GL_MAP2_VERTEX_3:
1532 data = ctx->EvalMap.Map2Vertex3.Points;
1533 n = ctx->EvalMap.Map2Vertex3.Uorder
1534 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1535 break;
1536 case GL_MAP2_VERTEX_4:
1537 data = ctx->EvalMap.Map2Vertex4.Points;
1538 n = ctx->EvalMap.Map2Vertex4.Uorder
1539 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1540 break;
1541 default:
1542 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1543 return;
1544 }
1545 if (data) {
1546 for (i=0;i<n;i++) {
1547 v[i] = data[i];
1548 }
1549 }
1550 break;
1551 case GL_ORDER:
1552 switch (target) {
1553 case GL_MAP1_COLOR_4:
1554 *v = ctx->EvalMap.Map1Color4.Order;
1555 break;
1556 case GL_MAP1_INDEX:
1557 *v = ctx->EvalMap.Map1Index.Order;
1558 break;
1559 case GL_MAP1_NORMAL:
1560 *v = ctx->EvalMap.Map1Normal.Order;
1561 break;
1562 case GL_MAP1_TEXTURE_COORD_1:
1563 *v = ctx->EvalMap.Map1Texture1.Order;
1564 break;
1565 case GL_MAP1_TEXTURE_COORD_2:
1566 *v = ctx->EvalMap.Map1Texture2.Order;
1567 break;
1568 case GL_MAP1_TEXTURE_COORD_3:
1569 *v = ctx->EvalMap.Map1Texture3.Order;
1570 break;
1571 case GL_MAP1_TEXTURE_COORD_4:
1572 *v = ctx->EvalMap.Map1Texture4.Order;
1573 break;
1574 case GL_MAP1_VERTEX_3:
1575 *v = ctx->EvalMap.Map1Vertex3.Order;
1576 break;
1577 case GL_MAP1_VERTEX_4:
1578 *v = ctx->EvalMap.Map1Vertex4.Order;
1579 break;
1580 case GL_MAP2_COLOR_4:
1581 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1582 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1583 break;
1584 case GL_MAP2_INDEX:
1585 v[0] = ctx->EvalMap.Map2Index.Uorder;
1586 v[1] = ctx->EvalMap.Map2Index.Vorder;
1587 break;
1588 case GL_MAP2_NORMAL:
1589 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1590 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1591 break;
1592 case GL_MAP2_TEXTURE_COORD_1:
1593 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1594 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1595 break;
1596 case GL_MAP2_TEXTURE_COORD_2:
1597 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1598 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1599 break;
1600 case GL_MAP2_TEXTURE_COORD_3:
1601 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1602 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1603 break;
1604 case GL_MAP2_TEXTURE_COORD_4:
1605 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1606 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1607 break;
1608 case GL_MAP2_VERTEX_3:
1609 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1610 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1611 break;
1612 case GL_MAP2_VERTEX_4:
1613 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1614 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1615 break;
1616 default:
1617 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1618 return;
1619 }
1620 break;
1621 case GL_DOMAIN:
1622 switch (target) {
1623 case GL_MAP1_COLOR_4:
1624 v[0] = ctx->EvalMap.Map1Color4.u1;
1625 v[1] = ctx->EvalMap.Map1Color4.u2;
1626 break;
1627 case GL_MAP1_INDEX:
1628 v[0] = ctx->EvalMap.Map1Index.u1;
1629 v[1] = ctx->EvalMap.Map1Index.u2;
1630 break;
1631 case GL_MAP1_NORMAL:
1632 v[0] = ctx->EvalMap.Map1Normal.u1;
1633 v[1] = ctx->EvalMap.Map1Normal.u2;
1634 break;
1635 case GL_MAP1_TEXTURE_COORD_1:
1636 v[0] = ctx->EvalMap.Map1Texture1.u1;
1637 v[1] = ctx->EvalMap.Map1Texture1.u2;
1638 break;
1639 case GL_MAP1_TEXTURE_COORD_2:
1640 v[0] = ctx->EvalMap.Map1Texture2.u1;
1641 v[1] = ctx->EvalMap.Map1Texture2.u2;
1642 break;
1643 case GL_MAP1_TEXTURE_COORD_3:
1644 v[0] = ctx->EvalMap.Map1Texture3.u1;
1645 v[1] = ctx->EvalMap.Map1Texture3.u2;
1646 break;
1647 case GL_MAP1_TEXTURE_COORD_4:
1648 v[0] = ctx->EvalMap.Map1Texture4.u1;
1649 v[1] = ctx->EvalMap.Map1Texture4.u2;
1650 break;
1651 case GL_MAP1_VERTEX_3:
1652 v[0] = ctx->EvalMap.Map1Vertex3.u1;
1653 v[1] = ctx->EvalMap.Map1Vertex3.u2;
1654 break;
1655 case GL_MAP1_VERTEX_4:
1656 v[0] = ctx->EvalMap.Map1Vertex4.u1;
1657 v[1] = ctx->EvalMap.Map1Vertex4.u2;
1658 break;
1659 case GL_MAP2_COLOR_4:
1660 v[0] = ctx->EvalMap.Map2Color4.u1;
1661 v[1] = ctx->EvalMap.Map2Color4.u2;
1662 v[2] = ctx->EvalMap.Map2Color4.v1;
1663 v[3] = ctx->EvalMap.Map2Color4.v2;
1664 break;
1665 case GL_MAP2_INDEX:
1666 v[0] = ctx->EvalMap.Map2Index.u1;
1667 v[1] = ctx->EvalMap.Map2Index.u2;
1668 v[2] = ctx->EvalMap.Map2Index.v1;
1669 v[3] = ctx->EvalMap.Map2Index.v2;
1670 break;
1671 case GL_MAP2_NORMAL:
1672 v[0] = ctx->EvalMap.Map2Normal.u1;
1673 v[1] = ctx->EvalMap.Map2Normal.u2;
1674 v[2] = ctx->EvalMap.Map2Normal.v1;
1675 v[3] = ctx->EvalMap.Map2Normal.v2;
1676 break;
1677 case GL_MAP2_TEXTURE_COORD_1:
1678 v[0] = ctx->EvalMap.Map2Texture1.u1;
1679 v[1] = ctx->EvalMap.Map2Texture1.u2;
1680 v[2] = ctx->EvalMap.Map2Texture1.v1;
1681 v[3] = ctx->EvalMap.Map2Texture1.v2;
1682 break;
1683 case GL_MAP2_TEXTURE_COORD_2:
1684 v[0] = ctx->EvalMap.Map2Texture2.u1;
1685 v[1] = ctx->EvalMap.Map2Texture2.u2;
1686 v[2] = ctx->EvalMap.Map2Texture2.v1;
1687 v[3] = ctx->EvalMap.Map2Texture2.v2;
1688 break;
1689 case GL_MAP2_TEXTURE_COORD_3:
1690 v[0] = ctx->EvalMap.Map2Texture3.u1;
1691 v[1] = ctx->EvalMap.Map2Texture3.u2;
1692 v[2] = ctx->EvalMap.Map2Texture3.v1;
1693 v[3] = ctx->EvalMap.Map2Texture3.v2;
1694 break;
1695 case GL_MAP2_TEXTURE_COORD_4:
1696 v[0] = ctx->EvalMap.Map2Texture4.u1;
1697 v[1] = ctx->EvalMap.Map2Texture4.u2;
1698 v[2] = ctx->EvalMap.Map2Texture4.v1;
1699 v[3] = ctx->EvalMap.Map2Texture4.v2;
1700 break;
1701 case GL_MAP2_VERTEX_3:
1702 v[0] = ctx->EvalMap.Map2Vertex3.u1;
1703 v[1] = ctx->EvalMap.Map2Vertex3.u2;
1704 v[2] = ctx->EvalMap.Map2Vertex3.v1;
1705 v[3] = ctx->EvalMap.Map2Vertex3.v2;
1706 break;
1707 case GL_MAP2_VERTEX_4:
1708 v[0] = ctx->EvalMap.Map2Vertex4.u1;
1709 v[1] = ctx->EvalMap.Map2Vertex4.u2;
1710 v[2] = ctx->EvalMap.Map2Vertex4.v1;
1711 v[3] = ctx->EvalMap.Map2Vertex4.v2;
1712 break;
1713 default:
1714 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1715 }
1716 break;
1717 default:
1718 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
1719 }
1720 }
1721
1722
1723 void gl_GetMapiv( GLcontext* ctx, GLenum target, GLenum query, GLint *v )
1724 {
1725 GLuint i, n;
1726 GLfloat *data;
1727
1728 switch (query) {
1729 case GL_COEFF:
1730 switch (target) {
1731 case GL_MAP1_COLOR_4:
1732 data = ctx->EvalMap.Map1Color4.Points;
1733 n = ctx->EvalMap.Map1Color4.Order * 4;
1734 break;
1735 case GL_MAP1_INDEX:
1736 data = ctx->EvalMap.Map1Index.Points;
1737 n = ctx->EvalMap.Map1Index.Order;
1738 break;
1739 case GL_MAP1_NORMAL:
1740 data = ctx->EvalMap.Map1Normal.Points;
1741 n = ctx->EvalMap.Map1Normal.Order * 3;
1742 break;
1743 case GL_MAP1_TEXTURE_COORD_1:
1744 data = ctx->EvalMap.Map1Texture1.Points;
1745 n = ctx->EvalMap.Map1Texture1.Order * 1;
1746 break;
1747 case GL_MAP1_TEXTURE_COORD_2:
1748 data = ctx->EvalMap.Map1Texture2.Points;
1749 n = ctx->EvalMap.Map1Texture2.Order * 2;
1750 break;
1751 case GL_MAP1_TEXTURE_COORD_3:
1752 data = ctx->EvalMap.Map1Texture3.Points;
1753 n = ctx->EvalMap.Map1Texture3.Order * 3;
1754 break;
1755 case GL_MAP1_TEXTURE_COORD_4:
1756 data = ctx->EvalMap.Map1Texture4.Points;
1757 n = ctx->EvalMap.Map1Texture4.Order * 4;
1758 break;
1759 case GL_MAP1_VERTEX_3:
1760 data = ctx->EvalMap.Map1Vertex3.Points;
1761 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1762 break;
1763 case GL_MAP1_VERTEX_4:
1764 data = ctx->EvalMap.Map1Vertex4.Points;
1765 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1766 break;
1767 case GL_MAP2_COLOR_4:
1768 data = ctx->EvalMap.Map2Color4.Points;
1769 n = ctx->EvalMap.Map2Color4.Uorder
1770 * ctx->EvalMap.Map2Color4.Vorder * 4;
1771 break;
1772 case GL_MAP2_INDEX:
1773 data = ctx->EvalMap.Map2Index.Points;
1774 n = ctx->EvalMap.Map2Index.Uorder
1775 * ctx->EvalMap.Map2Index.Vorder;
1776 break;
1777 case GL_MAP2_NORMAL:
1778 data = ctx->EvalMap.Map2Normal.Points;
1779 n = ctx->EvalMap.Map2Normal.Uorder
1780 * ctx->EvalMap.Map2Normal.Vorder * 3;
1781 break;
1782 case GL_MAP2_TEXTURE_COORD_1:
1783 data = ctx->EvalMap.Map2Texture1.Points;
1784 n = ctx->EvalMap.Map2Texture1.Uorder
1785 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1786 break;
1787 case GL_MAP2_TEXTURE_COORD_2:
1788 data = ctx->EvalMap.Map2Texture2.Points;
1789 n = ctx->EvalMap.Map2Texture2.Uorder
1790 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1791 break;
1792 case GL_MAP2_TEXTURE_COORD_3:
1793 data = ctx->EvalMap.Map2Texture3.Points;
1794 n = ctx->EvalMap.Map2Texture3.Uorder
1795 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1796 break;
1797 case GL_MAP2_TEXTURE_COORD_4:
1798 data = ctx->EvalMap.Map2Texture4.Points;
1799 n = ctx->EvalMap.Map2Texture4.Uorder
1800 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1801 break;
1802 case GL_MAP2_VERTEX_3:
1803 data = ctx->EvalMap.Map2Vertex3.Points;
1804 n = ctx->EvalMap.Map2Vertex3.Uorder
1805 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1806 break;
1807 case GL_MAP2_VERTEX_4:
1808 data = ctx->EvalMap.Map2Vertex4.Points;
1809 n = ctx->EvalMap.Map2Vertex4.Uorder
1810 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1811 break;
1812 default:
1813 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1814 return;
1815 }
1816 if (data) {
1817 for (i=0;i<n;i++) {
1818 v[i] = ROUNDF(data[i]);
1819 }
1820 }
1821 break;
1822 case GL_ORDER:
1823 switch (target) {
1824 case GL_MAP1_COLOR_4:
1825 *v = ctx->EvalMap.Map1Color4.Order;
1826 break;
1827 case GL_MAP1_INDEX:
1828 *v = ctx->EvalMap.Map1Index.Order;
1829 break;
1830 case GL_MAP1_NORMAL:
1831 *v = ctx->EvalMap.Map1Normal.Order;
1832 break;
1833 case GL_MAP1_TEXTURE_COORD_1:
1834 *v = ctx->EvalMap.Map1Texture1.Order;
1835 break;
1836 case GL_MAP1_TEXTURE_COORD_2:
1837 *v = ctx->EvalMap.Map1Texture2.Order;
1838 break;
1839 case GL_MAP1_TEXTURE_COORD_3:
1840 *v = ctx->EvalMap.Map1Texture3.Order;
1841 break;
1842 case GL_MAP1_TEXTURE_COORD_4:
1843 *v = ctx->EvalMap.Map1Texture4.Order;
1844 break;
1845 case GL_MAP1_VERTEX_3:
1846 *v = ctx->EvalMap.Map1Vertex3.Order;
1847 break;
1848 case GL_MAP1_VERTEX_4:
1849 *v = ctx->EvalMap.Map1Vertex4.Order;
1850 break;
1851 case GL_MAP2_COLOR_4:
1852 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1853 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1854 break;
1855 case GL_MAP2_INDEX:
1856 v[0] = ctx->EvalMap.Map2Index.Uorder;
1857 v[1] = ctx->EvalMap.Map2Index.Vorder;
1858 break;
1859 case GL_MAP2_NORMAL:
1860 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1861 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1862 break;
1863 case GL_MAP2_TEXTURE_COORD_1:
1864 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1865 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1866 break;
1867 case GL_MAP2_TEXTURE_COORD_2:
1868 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1869 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1870 break;
1871 case GL_MAP2_TEXTURE_COORD_3:
1872 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1873 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1874 break;
1875 case GL_MAP2_TEXTURE_COORD_4:
1876 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1877 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1878 break;
1879 case GL_MAP2_VERTEX_3:
1880 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1881 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1882 break;
1883 case GL_MAP2_VERTEX_4:
1884 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1885 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1886 break;
1887 default:
1888 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1889 return;
1890 }
1891 break;
1892 case GL_DOMAIN:
1893 switch (target) {
1894 case GL_MAP1_COLOR_4:
1895 v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
1896 v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
1897 break;
1898 case GL_MAP1_INDEX:
1899 v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
1900 v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
1901 break;
1902 case GL_MAP1_NORMAL:
1903 v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
1904 v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
1905 break;
1906 case GL_MAP1_TEXTURE_COORD_1:
1907 v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
1908 v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
1909 break;
1910 case GL_MAP1_TEXTURE_COORD_2:
1911 v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
1912 v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
1913 break;
1914 case GL_MAP1_TEXTURE_COORD_3:
1915 v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
1916 v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
1917 break;
1918 case GL_MAP1_TEXTURE_COORD_4:
1919 v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
1920 v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
1921 break;
1922 case GL_MAP1_VERTEX_3:
1923 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
1924 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
1925 break;
1926 case GL_MAP1_VERTEX_4:
1927 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
1928 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
1929 break;
1930 case GL_MAP2_COLOR_4:
1931 v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
1932 v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
1933 v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
1934 v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
1935 break;
1936 case GL_MAP2_INDEX:
1937 v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
1938 v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
1939 v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
1940 v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
1941 break;
1942 case GL_MAP2_NORMAL:
1943 v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
1944 v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
1945 v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
1946 v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
1947 break;
1948 case GL_MAP2_TEXTURE_COORD_1:
1949 v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
1950 v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
1951 v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
1952 v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
1953 break;
1954 case GL_MAP2_TEXTURE_COORD_2:
1955 v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
1956 v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
1957 v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
1958 v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
1959 break;
1960 case GL_MAP2_TEXTURE_COORD_3:
1961 v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
1962 v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
1963 v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
1964 v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
1965 break;
1966 case GL_MAP2_TEXTURE_COORD_4:
1967 v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
1968 v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
1969 v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
1970 v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
1971 break;
1972 case GL_MAP2_VERTEX_3:
1973 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
1974 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
1975 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
1976 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
1977 break;
1978 case GL_MAP2_VERTEX_4:
1979 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
1980 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
1981 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
1982 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
1983 break;
1984 default:
1985 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1986 }
1987 break;
1988 default:
1989 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
1990 }
1991 }
1992
1993
1994
1995 static void eval_points1( GLfloat outcoord[][4],
1996 GLfloat coord[][4],
1997 const GLuint *flags,
1998 GLfloat du, GLfloat u1 )
1999 {
2000 GLuint i;
2001 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2002 if (flags[i] & VERT_EVAL_P1)
2003 outcoord[i][0] = coord[i][0] * du + u1;
2004 else if (flags[i] & VERT_EVAL_ANY) {
2005 outcoord[i][0] = coord[i][0];
2006 outcoord[i][1] = coord[i][1];
2007 }
2008 }
2009
2010 static void eval_points2( GLfloat outcoord[][4],
2011 GLfloat coord[][4],
2012 const GLuint *flags,
2013 GLfloat du, GLfloat u1,
2014 GLfloat dv, GLfloat v1 )
2015 {
2016 GLuint i;
2017 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2018 if (flags[i] & VERT_EVAL_P2) {
2019 outcoord[i][0] = coord[i][0] * du + u1;
2020 outcoord[i][1] = coord[i][1] * dv + v1;
2021 } else if (flags[i] & VERT_EVAL_ANY) {
2022 outcoord[i][0] = coord[i][0];
2023 outcoord[i][1] = coord[i][1];
2024 }
2025 }
2026
2027
2028 static const GLubyte dirty_flags[5] = {
2029 0, /* not possible */
2030 VEC_DIRTY_0,
2031 VEC_DIRTY_1,
2032 VEC_DIRTY_2,
2033 VEC_DIRTY_3
2034 };
2035
2036
2037 static GLvector4f *eval1_4f( GLvector4f *dest,
2038 GLfloat coord[][4],
2039 const GLuint *flags,
2040 GLuint dimension,
2041 struct gl_1d_map *map )
2042 {
2043 const GLfloat u1 = map->u1;
2044 const GLfloat du = map->du;
2045 GLfloat (*to)[4] = dest->data;
2046 GLuint i;
2047
2048 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2049 if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
2050 GLfloat u = (coord[i][0] - u1) * du;
2051 ASSIGN_4V(to[i], 0,0,0,1);
2052 horner_bezier_curve(map->Points, to[i], u, dimension, map->Order);
2053 }
2054
2055 dest->count = i;
2056 dest->size = MAX2(dest->size, dimension);
2057 dest->flags |= dirty_flags[dimension];
2058 return dest;
2059 }
2060
2061
2062 static GLvector1ui *eval1_1ui( GLvector1ui *dest,
2063 GLfloat coord[][4],
2064 const GLuint *flags,
2065 struct gl_1d_map *map )
2066 {
2067 const GLfloat u1 = map->u1;
2068 const GLfloat du = map->du;
2069 GLuint *to = dest->data;
2070 GLuint i;
2071
2072 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2073 if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
2074 GLfloat u = (coord[i][0] - u1) * du;
2075 GLfloat tmp;
2076 horner_bezier_curve(map->Points, &tmp, u, 1, map->Order);
2077 to[i] = (GLuint) (GLint) tmp;
2078 }
2079
2080 dest->count = i;
2081 return dest;
2082 }
2083
2084 static GLvector3f *eval1_norm( GLvector3f *dest,
2085 GLfloat coord[][4],
2086 GLuint *flags, /* not const */
2087 struct gl_1d_map *map )
2088 {
2089 const GLfloat u1 = map->u1;
2090 const GLfloat du = map->du;
2091 GLfloat (*to)[3] = dest->data;
2092 GLuint i;
2093
2094 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2095 if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
2096 GLfloat u = (coord[i][0] - u1) * du;
2097 horner_bezier_curve(map->Points, to[i], u, 3, map->Order);
2098 flags[i+1] |= VERT_NORM; /* reset */
2099 }
2100
2101 dest->count = i;
2102 return dest;
2103 }
2104
2105 static GLvector4ub *eval1_color( GLvector4ub *dest,
2106 GLfloat coord[][4],
2107 GLuint *flags, /* not const */
2108 struct gl_1d_map *map )
2109 {
2110 const GLfloat u1 = map->u1;
2111 const GLfloat du = map->du;
2112 GLubyte (*to)[4] = dest->data;
2113 GLuint i;
2114
2115 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2116 if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
2117 GLfloat u = (coord[i][0] - u1) * du;
2118 GLfloat fcolor[4];
2119 horner_bezier_curve(map->Points, fcolor, u, 4, map->Order);
2120 FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
2121 flags[i+1] |= VERT_RGBA; /* reset */
2122 }
2123
2124 dest->count = i;
2125 return dest;
2126 }
2127
2128
2129
2130
2131 static GLvector4f *eval2_obj_norm( GLvector4f *obj_ptr,
2132 GLvector3f *norm_ptr,
2133 GLfloat coord[][4],
2134 GLuint *flags,
2135 GLuint dimension,
2136 struct gl_2d_map *map )
2137 {
2138 const GLfloat u1 = map->u1;
2139 const GLfloat du = map->du;
2140 const GLfloat v1 = map->v1;
2141 const GLfloat dv = map->dv;
2142 GLfloat (*obj)[4] = obj_ptr->data;
2143 GLfloat (*normal)[3] = norm_ptr->data;
2144 GLuint i;
2145
2146 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2147 if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
2148 GLfloat u = (coord[i][0] - u1) * du;
2149 GLfloat v = (coord[i][1] - v1) * dv;
2150 GLfloat du[4], dv[4];
2151
2152 ASSIGN_4V(obj[i], 0,0,0,1);
2153 de_casteljau_surf(map->Points, obj[i], du, dv, u, v, dimension,
2154 map->Uorder, map->Vorder);
2155
2156 CROSS3(normal[i], du, dv);
2157 NORMALIZE_3FV(normal[i]);
2158 flags[i+1] |= VERT_NORM;
2159 }
2160
2161 obj_ptr->count = i;
2162 obj_ptr->size = MAX2(obj_ptr->size, dimension);
2163 obj_ptr->flags |= dirty_flags[dimension];
2164 return obj_ptr;
2165 }
2166
2167
2168 static GLvector4f *eval2_4f( GLvector4f *dest,
2169 GLfloat coord[][4],
2170 const GLuint *flags,
2171 GLuint dimension,
2172 struct gl_2d_map *map )
2173 {
2174 const GLfloat u1 = map->u1;
2175 const GLfloat du = map->du;
2176 const GLfloat v1 = map->v1;
2177 const GLfloat dv = map->dv;
2178 GLfloat (*to)[4] = dest->data;
2179 GLuint i;
2180
2181 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2182 if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
2183 GLfloat u = (coord[i][0] - u1) * du;
2184 GLfloat v = (coord[i][1] - v1) * dv;
2185 horner_bezier_surf(map->Points, to[i], u, v, dimension,
2186 map->Uorder, map->Vorder);
2187 }
2188
2189 dest->count = i;
2190 dest->size = MAX2(dest->size, dimension);
2191 dest->flags |= dirty_flags[dimension];
2192 return dest;
2193 }
2194
2195
2196 static GLvector3f *eval2_norm( GLvector3f *dest,
2197 GLfloat coord[][4],
2198 GLuint *flags,
2199 struct gl_2d_map *map )
2200 {
2201 const GLfloat u1 = map->u1;
2202 const GLfloat du = map->du;
2203 const GLfloat v1 = map->v1;
2204 const GLfloat dv = map->dv;
2205 GLfloat (*to)[3] = dest->data;
2206 GLuint i;
2207
2208 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2209 if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
2210 GLfloat u = (coord[i][0] - u1) * du;
2211 GLfloat v = (coord[i][1] - v1) * dv;
2212 horner_bezier_surf(map->Points, to[i], u, v, 3,
2213 map->Uorder, map->Vorder);
2214 flags[i+1] |= VERT_NORM; /* reset */
2215 }
2216
2217 dest->count = i;
2218 return dest;
2219 }
2220
2221
2222 static GLvector1ui *eval2_1ui( GLvector1ui *dest,
2223 GLfloat coord[][4],
2224 const GLuint *flags,
2225 struct gl_2d_map *map )
2226 {
2227 const GLfloat u1 = map->u1;
2228 const GLfloat du = map->du;
2229 const GLfloat v1 = map->v1;
2230 const GLfloat dv = map->dv;
2231 GLuint *to = dest->data;
2232 GLuint i;
2233
2234 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2235 if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
2236 GLfloat u = (coord[i][0] - u1) * du;
2237 GLfloat v = (coord[i][1] - v1) * dv;
2238 GLfloat tmp;
2239 horner_bezier_surf(map->Points, &tmp, u, v, 1,
2240 map->Uorder, map->Vorder);
2241
2242 to[i] = (GLuint) (GLint) tmp;
2243 }
2244
2245 dest->count = i;
2246 return dest;
2247 }
2248
2249
2250
2251 static GLvector4ub *eval2_color( GLvector4ub *dest,
2252 GLfloat coord[][4],
2253 GLuint *flags,
2254 struct gl_2d_map *map )
2255 {
2256 const GLfloat u1 = map->u1;
2257 const GLfloat du = map->du;
2258 const GLfloat v1 = map->v1;
2259 const GLfloat dv = map->dv;
2260 GLubyte (*to)[4] = dest->data;
2261 GLuint i;
2262
2263 for (i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2264 if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
2265 GLfloat u = (coord[i][0] - u1) * du;
2266 GLfloat v = (coord[i][1] - v1) * dv;
2267 GLfloat fcolor[4];
2268 horner_bezier_surf(map->Points, fcolor, u, v, 4,
2269 map->Uorder, map->Vorder);
2270 FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
2271 flags[i+1] |= VERT_RGBA; /* reset */
2272 }
2273
2274 dest->count = i;
2275 return dest;
2276 }
2277
2278
2279 static GLvector4f *copy_4f( GLvector4f *out, CONST GLvector4f *in,
2280 const GLuint *flags)
2281 {
2282 GLfloat (*to)[4] = out->data;
2283 GLfloat (*from)[4] = in->data;
2284 GLuint i;
2285
2286 for ( i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2287 if (!(flags[i] & VERT_EVAL_ANY))
2288 COPY_4FV( to[i], from[i] );
2289
2290 return out;
2291 }
2292
2293 static GLvector3f *copy_3f( GLvector3f *out, CONST GLvector3f *in,
2294 const GLuint *flags)
2295 {
2296 GLfloat (*to)[3] = out->data;
2297 GLfloat (*from)[3] = in->data;
2298 GLuint i;
2299
2300 for ( i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2301 if (!(flags[i] & VERT_EVAL_ANY))
2302 COPY_3V( to[i], from[i] );
2303
2304 return out;
2305 }
2306
2307 static GLvector4ub *copy_4ub( GLvector4ub *out, CONST GLvector4ub *in,
2308 const GLuint *flags )
2309 {
2310 GLubyte (*to)[4] = out->data;
2311 GLubyte (*from)[4] = in->data;
2312 GLuint i;
2313
2314 for ( i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2315 if (!(flags[i] & VERT_EVAL_ANY))
2316 COPY_4UBV( to[i], from[i] );
2317
2318 return out;
2319 }
2320
2321 static GLvector1ui *copy_1ui( GLvector1ui *out, CONST GLvector1ui *in,
2322 const GLuint *flags )
2323 {
2324 GLuint *to = out->data;
2325 CONST GLuint *from = in->data;
2326 GLuint i;
2327
2328 for ( i = VB_START ; !(flags[i] & VERT_END_VB) ; i++)
2329 if (!(flags[i] & VERT_EVAL_ANY))
2330 to[i] = from[i];
2331
2332 return out;
2333 }
2334
2335
2336 /* KW: Rewrote this to perform eval on a whole buffer at once.
2337 * Only evaluates active data items, and avoids scribbling
2338 * the source buffer if we are running from a display list.
2339 *
2340 * If the user (in this case looser) sends eval coordinates
2341 * or runs a display list containing eval coords with no
2342 * vertex maps enabled, we have to either copy all non-eval
2343 * data to a new buffer, or find a way of working around
2344 * the eval data. I choose the second option.
2345 *
2346 * KW: This code not reached by cva - use IM to access storage.
2347 */
2348 void gl_eval_vb( struct vertex_buffer *VB )
2349 {
2350 struct immediate *IM = VB->IM;
2351 GLcontext *ctx = VB->ctx;
2352 GLuint req = ctx->CVA.elt.inputs;
2353 GLfloat (*coord)[4] = VB->ObjPtr->data;
2354 GLuint *flags = VB->Flag;
2355 GLuint new_flags = 0;
2356
2357
2358 GLuint any_eval1 = VB->OrFlag & (VERT_EVAL_C1|VERT_EVAL_P1);
2359 GLuint any_eval2 = VB->OrFlag & (VERT_EVAL_C2|VERT_EVAL_P2);
2360 GLuint all_eval = VB->AndFlag & VERT_EVAL_ANY;
2361
2362 /* Handle the degenerate cases.
2363 */
2364 if (any_eval1 && !ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3) {
2365 VB->PurgeFlags |= (VERT_EVAL_C1|VERT_EVAL_P1);
2366 VB->EarlyCull = 0;
2367 any_eval1 = GL_FALSE;
2368 }
2369
2370 if (any_eval2 && !ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3) {
2371 VB->PurgeFlags |= (VERT_EVAL_C2|VERT_EVAL_P2);
2372 VB->EarlyCull = 0;
2373 any_eval2 = GL_FALSE;
2374 }
2375
2376 /* KW: This really is a degenerate case - doing this disables
2377 * culling, and causes dummy values for the missing vertices to be
2378 * transformed and clip tested. It also forces the individual
2379 * cliptesting of each primitive in vb_render. I wish there was a
2380 * nice alternative, but I can't say I want to put effort into
2381 * optimizing such a bad usage of the library - I'd much rather
2382 * work on useful changes.
2383 */
2384 if (VB->PurgeFlags) {
2385 if (!any_eval1 && !any_eval2 && all_eval) VB->Count = VB_START;
2386 gl_purge_vertices( VB );
2387 if (!any_eval1 && !any_eval2) return;
2388 } else
2389 VB->IndirectCount = VB->Count;
2390
2391 /* Translate points into coords.
2392 */
2393 if (any_eval1 && (VB->OrFlag & VERT_EVAL_P1))
2394 {
2395 eval_points1( IM->Obj, coord, flags,
2396 ctx->Eval.MapGrid1du,
2397 ctx->Eval.MapGrid1u1);
2398
2399 coord = IM->Obj;
2400 }
2401
2402 if (any_eval2 && (VB->OrFlag & VERT_EVAL_P2))
2403 {
2404 eval_points2( IM->Obj, coord, flags,
2405 ctx->Eval.MapGrid2du,
2406 ctx->Eval.MapGrid2u1,
2407 ctx->Eval.MapGrid2dv,
2408 ctx->Eval.MapGrid2v1 );
2409
2410 coord = IM->Obj;
2411 }
2412
2413 /* Perform the evaluations on active data elements.
2414 */
2415 if (req & VERT_INDEX)
2416 {
2417 GLvector1ui *in_index = VB->IndexPtr;
2418 GLvector1ui *out_index = &IM->v.Index;
2419
2420 if (ctx->Eval.Map1Index && any_eval1)
2421 VB->IndexPtr = eval1_1ui( out_index, coord, flags,
2422 &ctx->EvalMap.Map1Index );
2423
2424 if (ctx->Eval.Map2Index && any_eval2)
2425 VB->IndexPtr = eval2_1ui( out_index, coord, flags,
2426 &ctx->EvalMap.Map2Index );
2427
2428 if (VB->IndexPtr != in_index) {
2429 new_flags |= VERT_INDEX;
2430 if (!all_eval)
2431 VB->IndexPtr = copy_1ui( out_index, in_index, flags );
2432 }
2433 }
2434
2435 if (req & VERT_RGBA)
2436 {
2437 GLvector4ub *in_color = VB->ColorPtr;
2438 GLvector4ub *out_color = &IM->v.Color;
2439
2440 if (ctx->Eval.Map1Color4 && any_eval1)
2441 VB->ColorPtr = eval1_color( out_color, coord, flags,
2442 &ctx->EvalMap.Map1Color4 );
2443
2444 if (ctx->Eval.Map2Color4 && any_eval2)
2445 VB->ColorPtr = eval2_color( out_color, coord, flags,
2446 &ctx->EvalMap.Map2Color4 );
2447
2448 if (VB->ColorPtr != in_color) {
2449 new_flags |= VERT_RGBA;
2450 if (!all_eval)
2451 VB->ColorPtr = copy_4ub( out_color, in_color, flags );
2452 }
2453
2454 VB->Color[0] = VB->Color[1] = VB->ColorPtr;
2455 }
2456
2457
2458 if (req & VERT_NORM)
2459 {
2460 GLvector3f *in_normal = VB->NormalPtr;
2461 GLvector3f *out_normal = &IM->v.Normal;
2462
2463 if (ctx->Eval.Map1Normal && any_eval1)
2464 VB->NormalPtr = eval1_norm( out_normal, coord, flags,
2465 &ctx->EvalMap.Map1Normal );
2466
2467 if (ctx->Eval.Map2Normal && any_eval2)
2468 VB->NormalPtr = eval2_norm( out_normal, coord, flags,
2469 &ctx->EvalMap.Map2Normal );
2470
2471 if (VB->NormalPtr != in_normal) {
2472 new_flags |= VERT_NORM;
2473 if (!all_eval)
2474 VB->NormalPtr = copy_3f( out_normal, in_normal, flags );
2475 }
2476 }
2477
2478
2479 if (req & VERT_TEX_ANY(0))
2480 {
2481 GLvector4f *tc = VB->TexCoordPtr[0];
2482 GLvector4f *in = tc;
2483 GLvector4f *out = &IM->v.TexCoord[0];
2484
2485 if (any_eval1) {
2486 if (ctx->Eval.Map1TextureCoord4)
2487 tc = eval1_4f( out, coord, flags, 4, &ctx->EvalMap.Map1Texture4);
2488 else if (ctx->Eval.Map1TextureCoord3)
2489 tc = eval1_4f( out, coord, flags, 3, &ctx->EvalMap.Map1Texture3);
2490 else if (ctx->Eval.Map1TextureCoord2)
2491 tc = eval1_4f( out, coord, flags, 2, &ctx->EvalMap.Map1Texture2);
2492 else if (ctx->Eval.Map1TextureCoord1)
2493 tc = eval1_4f( out, coord, flags, 1, &ctx->EvalMap.Map1Texture1);
2494 }
2495
2496 if (any_eval2) {
2497 if (ctx->Eval.Map2TextureCoord4)
2498 tc = eval2_4f( out, coord, flags, 4, &ctx->EvalMap.Map2Texture4);
2499 else if (ctx->Eval.Map2TextureCoord3)
2500 tc = eval2_4f( out, coord, flags, 3, &ctx->EvalMap.Map2Texture3);
2501 else if (ctx->Eval.Map2TextureCoord2)
2502 tc = eval2_4f( out, coord, flags, 2, &ctx->EvalMap.Map2Texture2);
2503 else if (ctx->Eval.Map2TextureCoord1)
2504 tc = eval2_4f( out, coord, flags, 1, &ctx->EvalMap.Map2Texture1);
2505 }
2506
2507 if (tc != in) {
2508 new_flags |= VERT_TEX_ANY(0); /* fix for sizes.. */
2509 if (!all_eval)
2510 tc = copy_4f( out, in, flags );
2511 }
2512
2513 VB->TexCoordPtr[0] = tc;
2514 }
2515
2516
2517 {
2518 GLvector4f *in = VB->ObjPtr;
2519 GLvector4f *out = &IM->v.Obj;
2520 GLvector4f *obj = in;
2521
2522 if (any_eval1) {
2523 if (ctx->Eval.Map1Vertex4)
2524 obj = eval1_4f( out, coord, flags, 4, &ctx->EvalMap.Map1Vertex4);
2525 else
2526 obj = eval1_4f( out, coord, flags, 3, &ctx->EvalMap.Map1Vertex3);
2527 }
2528
2529 if (any_eval2) {
2530 if (ctx->Eval.Map2Vertex4)
2531 {
2532 if (ctx->Eval.AutoNormal && (req & VERT_NORM))
2533 obj = eval2_obj_norm( out, VB->NormalPtr, coord, flags, 4,
2534 &ctx->EvalMap.Map2Vertex4 );
2535 else
2536 obj = eval2_4f( out, coord, flags, 4,
2537 &ctx->EvalMap.Map2Vertex4);
2538 }
2539 else if (ctx->Eval.Map2Vertex3)
2540 {
2541 if (ctx->Eval.AutoNormal && (req & VERT_NORM))
2542 obj = eval2_obj_norm( out, VB->NormalPtr, coord, flags, 3,
2543 &ctx->EvalMap.Map2Vertex3 );
2544 else
2545 obj = eval2_4f( out, coord, flags, 3,
2546 &ctx->EvalMap.Map2Vertex3 );
2547 }
2548 }
2549
2550 if (obj != in && !all_eval)
2551 obj = copy_4f( out, in, flags );
2552
2553 VB->ObjPtr = obj;
2554 }
2555
2556 if (new_flags) {
2557 GLuint *oldflags = VB->Flag;
2558 GLuint *flags = VB->Flag = VB->EvaluatedFlags;
2559 GLuint i;
2560 GLuint count = VB->Count;
2561
2562 if (!flags) {
2563 VB->EvaluatedFlags = (GLuint *)malloc(VB->Size * sizeof(GLuint));
2564 flags = VB->Flag = VB->EvaluatedFlags;
2565 }
2566
2567 if (all_eval) {
2568 for (i = 0 ; i < count ; i++)
2569 flags[i] = oldflags[i] | new_flags;
2570 VB->AndFlag |= new_flags;
2571 } else {
2572 GLuint andflag = ~0;
2573 for (i = 0 ; i < count ; i++) {
2574 if (oldflags[i] & VERT_EVAL_ANY)
2575 flags[i] = oldflags[i] | new_flags;
2576 andflag &= flags[i];
2577 }
2578 VB->AndFlag = andflag;
2579 }
2580 }
2581 }
2582
2583
2584 void gl_MapGrid1f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2 )
2585 {
2586 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMapGrid1f");
2587
2588 if (un<1) {
2589 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
2590 return;
2591 }
2592 ctx->Eval.MapGrid1un = un;
2593 ctx->Eval.MapGrid1u1 = u1;
2594 ctx->Eval.MapGrid1u2 = u2;
2595 ctx->Eval.MapGrid1du = (u2 - u1) / (GLfloat) un;
2596 }
2597
2598
2599 void gl_MapGrid2f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2,
2600 GLint vn, GLfloat v1, GLfloat v2 )
2601 {
2602 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMapGrid2f");
2603 if (un<1) {
2604 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
2605 return;
2606 }
2607 if (vn<1) {
2608 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
2609 return;
2610 }
2611 ctx->Eval.MapGrid2un = un;
2612 ctx->Eval.MapGrid2u1 = u1;
2613 ctx->Eval.MapGrid2u2 = u2;
2614 ctx->Eval.MapGrid2du = (u2 - u1) / (GLfloat) un;
2615 ctx->Eval.MapGrid2vn = vn;
2616 ctx->Eval.MapGrid2v1 = v1;
2617 ctx->Eval.MapGrid2v2 = v2;
2618 ctx->Eval.MapGrid2dv = (v2 - v1) / (GLfloat) vn;
2619 }
2620
2621
2622
2623 void gl_EvalMesh1( GLcontext* ctx, GLenum mode, GLint i1, GLint i2 )
2624 {
2625 GLint i;
2626 GLfloat u, du;
2627 GLenum prim;
2628
2629 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh1");
2630
2631 switch (mode) {
2632 case GL_POINT:
2633 prim = GL_POINTS;
2634 break;
2635 case GL_LINE:
2636 prim = GL_LINE_STRIP;
2637 break;
2638 default:
2639 gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
2640 return;
2641 }
2642
2643 /* No effect if vertex maps disabled.
2644 */
2645 if (!ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3)
2646 return;
2647
2648 du = ctx->Eval.MapGrid1du;
2649 u = ctx->Eval.MapGrid1u1 + i1 * du;
2650
2651 /* KW: Could short-circuit this to avoid the immediate mechanism.
2652 */
2653 RESET_IMMEDIATE(ctx);
2654
2655 gl_Begin( ctx, prim );
2656 for (i=i1;i<=i2;i++,u+=du) {
2657 gl_EvalCoord1f( ctx, u );
2658 }
2659 gl_End(ctx);
2660 }
2661
2662
2663
2664 void gl_EvalMesh2( GLcontext* ctx,
2665 GLenum mode,
2666 GLint i1, GLint i2,
2667 GLint j1, GLint j2 )
2668 {
2669 GLint i, j;
2670 GLfloat u, du, v, dv, v1, u1;
2671
2672 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh2");
2673
2674 /* No effect if vertex maps disabled.
2675 */
2676 if (!ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3)
2677 return;
2678
2679 du = ctx->Eval.MapGrid2du;
2680 dv = ctx->Eval.MapGrid2dv;
2681 v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
2682 u1 = ctx->Eval.MapGrid2u1 + i1 * du;
2683
2684 RESET_IMMEDIATE(ctx);
2685
2686 switch (mode) {
2687 case GL_POINT:
2688 gl_Begin( ctx, GL_POINTS );
2689 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
2690 for (u=u1,i=i1;i<=i2;i++,u+=du) {
2691 gl_EvalCoord2f( ctx, u, v );
2692 }
2693 }
2694 gl_End(ctx);
2695 break;
2696 case GL_LINE:
2697 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
2698 gl_Begin( ctx, GL_LINE_STRIP );
2699 for (u=u1,i=i1;i<=i2;i++,u+=du) {
2700 gl_EvalCoord2f( ctx, u, v );
2701 }
2702 gl_End(ctx);
2703 }
2704 for (u=u1,i=i1;i<=i2;i++,u+=du) {
2705 gl_Begin( ctx, GL_LINE_STRIP );
2706 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
2707 gl_EvalCoord2f( ctx, u, v );
2708 }
2709 gl_End(ctx);
2710 }
2711 break;
2712 case GL_FILL:
2713 for (v=v1,j=j1;j<j2;j++,v+=dv) {
2714 /* NOTE: a quad strip can't be used because the four */
2715 /* can't be guaranteed to be coplanar! */
2716 gl_Begin( ctx, GL_TRIANGLE_STRIP );
2717 for (u=u1,i=i1;i<=i2;i++,u+=du) {
2718 gl_EvalCoord2f( ctx, u, v );
2719 gl_EvalCoord2f( ctx, u, v+dv );
2720 }
2721 gl_End(ctx);
2722 }
2723 break;
2724 default:
2725 gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
2726 return;
2727 }
2728 }
2729