ReactOS  0.4.14-dev-49-gfb4591c
eval.c
Go to the documentation of this file.
1 /* $Id: eval.c,v 1.9 1998/02/03 00:53:51 brianp Exp $ */
2 
3 /*
4  * Mesa 3-D graphics library
5  * Version: 2.6
6  * Copyright (C) 1995-1997 Brian Paul
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the Free
20  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22 
23 
24 /*
25  * $Log: eval.c,v $
26  * Revision 1.9 1998/02/03 00:53:51 brianp
27  * fixed bug in gl_copy_map_points*() functions (Sam Jordan)
28  *
29  * Revision 1.8 1997/07/24 01:25:01 brianp
30  * changed precompiled header symbol from PCH to PC_HEADER
31  *
32  * Revision 1.7 1997/06/20 01:58:47 brianp
33  * changed color components from GLfixed to GLubyte
34  *
35  * Revision 1.6 1997/05/28 03:24:22 brianp
36  * added precompiled header (PCH) support
37  *
38  * Revision 1.5 1997/05/14 03:27:04 brianp
39  * removed context argument from gl_init_eval()
40  *
41  * Revision 1.4 1997/05/01 01:38:38 brianp
42  * use NORMALIZE_3FV() from mmath.h instead of private NORMALIZE() macro
43  *
44  * Revision 1.3 1997/04/02 03:10:58 brianp
45  * changed some #include's
46  *
47  * Revision 1.2 1996/09/15 14:17:30 brianp
48  * now use GLframebuffer and GLvisual
49  *
50  * Revision 1.1 1996/09/13 01:38:16 brianp
51  * Initial revision
52  *
53  */
54 
55 
56 /*
57  * eval.c was written by
58  * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
59  * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
60  *
61  * My original implementation of evaluators was simplistic and didn't
62  * compute surface normal vectors properly. Bernd and Volker applied
63  * used more sophisticated methods to get better results.
64  *
65  * Thanks guys!
66  */
67 
68 
69 #ifdef PC_HEADER
70 #include "all.h"
71 #else
72 #include <math.h>
73 #include <stdlib.h>
74 #include <string.h>
75 #include "context.h"
76 #include "eval.h"
77 #include "dlist.h"
78 #include "macros.h"
79 #include "mmath.h"
80 #include "types.h"
81 #include "vbfill.h"
82 #endif
83 
84 
85 
86 /*
87  * Do one-time initialization for evaluators.
88  */
89 void gl_init_eval( void )
90 {
91  static int init_flag = 0;
92 
93  /* Compute a table of nCr (combination) values used by the
94  * Bernstein polynomial generator.
95  */
96 
97  if (init_flag==0)
98  { /* no initialization needed */
99  }
100 
101  init_flag = 1;
102 }
103 
104 
105 
106 /*
107  * Horner scheme for Bezier curves
108  *
109  * Bezier curves can be computed via a Horner scheme.
110  * Horner is numerically less stable than the de Casteljau
111  * algorithm, but it is faster. For curves of degree n
112  * the complexity of Horner is O(n) and de Casteljau is O(n^2).
113  * Since stability is not important for displaying curve
114  * points I decided to use the Horner scheme.
115  *
116  * A cubic Bezier curve with control points b0, b1, b2, b3 can be
117  * written as
118  *
119  * (([3] [3] ) [3] ) [3]
120  * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
121  *
122  * [n]
123  * where s=1-t and the binomial coefficients [i]. These can
124  * be computed iteratively using the identity:
125  *
126  * [n] [n ] [n]
127  * [i] = (n-i+1)/i * [i-1] and [0] = 1
128  */
129 
130 static void
132  GLuint dim, GLuint order)
133 {
134  GLfloat s, powert;
135  GLuint i, k, bincoeff;
136 
137  if(order >= 2)
138  {
139  bincoeff = order-1;
140  s = 1.0-t;
141 
142  for(k=0; k<dim; k++)
143  out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
144 
145  for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
146  {
147  bincoeff *= order-i;
148  bincoeff /= i;
149 
150  for(k=0; k<dim; k++)
151  out[k] = s*out[k] + bincoeff*powert*cp[k];
152  }
153  }
154  else /* order=1 -> constant curve */
155  {
156  for(k=0; k<dim; k++)
157  out[k] = cp[k];
158  }
159 }
160 
161 /*
162  * Tensor product Bezier surfaces
163  *
164  * Again the Horner scheme is used to compute a point on a
165  * TP Bezier surface. First a control polygon for a curve
166  * on the surface in one parameter direction is computed,
167  * then the point on the curve for the other parameter
168  * direction is evaluated.
169  *
170  * To store the curve control polygon additional storage
171  * for max(uorder,vorder) points is needed in the
172  * control net cn.
173  */
174 
175 static void
178 {
179  GLfloat *cp = cn + uorder*vorder*dim;
180  GLuint i, uinc = vorder*dim;
181 
182  if(vorder > uorder)
183  {
184  if(uorder >= 2)
185  {
186  GLfloat s, poweru;
187  GLuint j, k, bincoeff;
188 
189  /* Compute the control polygon for the surface-curve in u-direction */
190  for(j=0; j<vorder; j++)
191  {
192  GLfloat *ucp = &cn[j*dim];
193 
194  /* Each control point is the point for parameter u on a */
195  /* curve defined by the control polygons in u-direction */
196  bincoeff = uorder-1;
197  s = 1.0-u;
198 
199  for(k=0; k<dim; k++)
200  cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
201 
202  for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder;
203  i++, poweru*=u, ucp +=uinc)
204  {
205  bincoeff *= uorder-i;
206  bincoeff /= i;
207 
208  for(k=0; k<dim; k++)
209  cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
210  }
211  }
212 
213  /* Evaluate curve point in v */
214  horner_bezier_curve(cp, out, v, dim, vorder);
215  }
216  else /* uorder=1 -> cn defines a curve in v */
217  horner_bezier_curve(cn, out, v, dim, vorder);
218  }
219  else /* vorder <= uorder */
220  {
221  if(vorder > 1)
222  {
223  GLuint i;
224 
225  /* Compute the control polygon for the surface-curve in u-direction */
226  for(i=0; i<uorder; i++, cn += uinc)
227  {
228  /* For constant i all cn[i][j] (j=0..vorder) are located */
229  /* on consecutive memory locations, so we can use */
230  /* horner_bezier_curve to compute the control points */
231 
232  horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
233  }
234 
235  /* Evaluate curve point in u */
236  horner_bezier_curve(cp, out, u, dim, uorder);
237  }
238  else /* vorder=1 -> cn defines a curve in u */
239  horner_bezier_curve(cn, out, u, dim, uorder);
240  }
241 }
242 
243 /*
244  * The direct de Casteljau algorithm is used when a point on the
245  * surface and the tangent directions spanning the tangent plane
246  * should be computed (this is needed to compute normals to the
247  * surface). In this case the de Casteljau algorithm approach is
248  * nicer because a point and the partial derivatives can be computed
249  * at the same time. To get the correct tangent length du and dv
250  * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1.
251  * Since only the directions are needed, this scaling step is omitted.
252  *
253  * De Casteljau needs additional storage for uorder*vorder
254  * values in the control net cn.
255  */
256 
257 static void
259  GLfloat u, GLfloat v, GLuint dim,
261 {
262  GLfloat *dcn = cn + uorder*vorder*dim;
263  GLfloat us = 1.0-u, vs = 1.0-v;
264  GLuint h, i, j, k;
265  GLuint minorder = uorder < vorder ? uorder : vorder;
266  GLuint uinc = vorder*dim;
267  GLuint dcuinc = vorder;
268 
269  /* Each component is evaluated separately to save buffer space */
270  /* This does not drasticaly decrease the performance of the */
271  /* algorithm. If additional storage for (uorder-1)*(vorder-1) */
272  /* points would be available, the components could be accessed */
273  /* in the innermost loop which could lead to less cache misses. */
274 
275 #define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)]
276 #define DCN(I, J) dcn[(I)*dcuinc+(J)]
277  if(minorder < 3)
278  {
279  if(uorder==vorder)
280  {
281  for(k=0; k<dim; k++)
282  {
283  /* Derivative direction in u */
284  du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
285  v*(CN(1,1,k) - CN(0,1,k));
286 
287  /* Derivative direction in v */
288  dv[k] = us*(CN(0,1,k) - CN(0,0,k)) +
289  u*(CN(1,1,k) - CN(1,0,k));
290 
291  /* bilinear de Casteljau step */
292  out[k] = us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
293  u*(vs*CN(1,0,k) + v*CN(1,1,k));
294  }
295  }
296  else if(minorder == uorder)
297  {
298  for(k=0; k<dim; k++)
299  {
300  /* bilinear de Casteljau step */
301  DCN(1,0) = CN(1,0,k) - CN(0,0,k);
302  DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
303 
304  for(j=0; j<vorder-1; j++)
305  {
306  /* for the derivative in u */
307  DCN(1,j+1) = CN(1,j+1,k) - CN(0,j+1,k);
308  DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
309 
310  /* for the `point' */
311  DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
312  DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
313  }
314 
315  /* remaining linear de Casteljau steps until the second last step */
316  for(h=minorder; h<vorder-1; h++)
317  for(j=0; j<vorder-h; j++)
318  {
319  /* for the derivative in u */
320  DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
321 
322  /* for the `point' */
323  DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
324  }
325 
326  /* derivative direction in v */
327  dv[k] = DCN(0,1) - DCN(0,0);
328 
329  /* derivative direction in u */
330  du[k] = vs*DCN(1,0) + v*DCN(1,1);
331 
332  /* last linear de Casteljau step */
333  out[k] = vs*DCN(0,0) + v*DCN(0,1);
334  }
335  }
336  else /* minorder == vorder */
337  {
338  for(k=0; k<dim; k++)
339  {
340  /* bilinear de Casteljau step */
341  DCN(0,1) = CN(0,1,k) - CN(0,0,k);
342  DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
343  for(i=0; i<uorder-1; i++)
344  {
345  /* for the derivative in v */
346  DCN(i+1,1) = CN(i+1,1,k) - CN(i+1,0,k);
347  DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
348 
349  /* for the `point' */
350  DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
351  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
352  }
353 
354  /* remaining linear de Casteljau steps until the second last step */
355  for(h=minorder; h<uorder-1; h++)
356  for(i=0; i<uorder-h; i++)
357  {
358  /* for the derivative in v */
359  DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
360 
361  /* for the `point' */
362  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
363  }
364 
365  /* derivative direction in u */
366  du[k] = DCN(1,0) - DCN(0,0);
367 
368  /* derivative direction in v */
369  dv[k] = us*DCN(0,1) + u*DCN(1,1);
370 
371  /* last linear de Casteljau step */
372  out[k] = us*DCN(0,0) + u*DCN(1,0);
373  }
374  }
375  }
376  else if(uorder == vorder)
377  {
378  for(k=0; k<dim; k++)
379  {
380  /* first bilinear de Casteljau step */
381  for(i=0; i<uorder-1; i++)
382  {
383  DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
384  for(j=0; j<vorder-1; j++)
385  {
386  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
387  DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
388  }
389  }
390 
391  /* remaining bilinear de Casteljau steps until the second last step */
392  for(h=2; h<minorder-1; h++)
393  for(i=0; i<uorder-h; i++)
394  {
395  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
396  for(j=0; j<vorder-h; j++)
397  {
398  DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
399  DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
400  }
401  }
402 
403  /* derivative direction in u */
404  du[k] = vs*(DCN(1,0) - DCN(0,0)) +
405  v*(DCN(1,1) - DCN(0,1));
406 
407  /* derivative direction in v */
408  dv[k] = us*(DCN(0,1) - DCN(0,0)) +
409  u*(DCN(1,1) - DCN(1,0));
410 
411  /* last bilinear de Casteljau step */
412  out[k] = us*(vs*DCN(0,0) + v*DCN(0,1)) +
413  u*(vs*DCN(1,0) + v*DCN(1,1));
414  }
415  }
416  else if(minorder == uorder)
417  {
418  for(k=0; k<dim; k++)
419  {
420  /* first bilinear de Casteljau step */
421  for(i=0; i<uorder-1; i++)
422  {
423  DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
424  for(j=0; j<vorder-1; j++)
425  {
426  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
427  DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
428  }
429  }
430 
431  /* remaining bilinear de Casteljau steps until the second last step */
432  for(h=2; h<minorder-1; h++)
433  for(i=0; i<uorder-h; i++)
434  {
435  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
436  for(j=0; j<vorder-h; j++)
437  {
438  DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
439  DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
440  }
441  }
442 
443  /* last bilinear de Casteljau step */
444  DCN(2,0) = DCN(1,0) - DCN(0,0);
445  DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
446  for(j=0; j<vorder-1; j++)
447  {
448  /* for the derivative in u */
449  DCN(2,j+1) = DCN(1,j+1) - DCN(0,j+1);
450  DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
451 
452  /* for the `point' */
453  DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
454  DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
455  }
456 
457  /* remaining linear de Casteljau steps until the second last step */
458  for(h=minorder; h<vorder-1; h++)
459  for(j=0; j<vorder-h; j++)
460  {
461  /* for the derivative in u */
462  DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
463 
464  /* for the `point' */
465  DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
466  }
467 
468  /* derivative direction in v */
469  dv[k] = DCN(0,1) - DCN(0,0);
470 
471  /* derivative direction in u */
472  du[k] = vs*DCN(2,0) + v*DCN(2,1);
473 
474  /* last linear de Casteljau step */
475  out[k] = vs*DCN(0,0) + v*DCN(0,1);
476  }
477  }
478  else /* minorder == vorder */
479  {
480  for(k=0; k<dim; k++)
481  {
482  /* first bilinear de Casteljau step */
483  for(i=0; i<uorder-1; i++)
484  {
485  DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
486  for(j=0; j<vorder-1; j++)
487  {
488  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
489  DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
490  }
491  }
492 
493  /* remaining bilinear de Casteljau steps until the second last step */
494  for(h=2; h<minorder-1; h++)
495  for(i=0; i<uorder-h; i++)
496  {
497  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
498  for(j=0; j<vorder-h; j++)
499  {
500  DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
501  DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
502  }
503  }
504 
505  /* last bilinear de Casteljau step */
506  DCN(0,2) = DCN(0,1) - DCN(0,0);
507  DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
508  for(i=0; i<uorder-1; i++)
509  {
510  /* for the derivative in v */
511  DCN(i+1,2) = DCN(i+1,1) - DCN(i+1,0);
512  DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
513 
514  /* for the `point' */
515  DCN(i+1,0) = vs*DCN(i+1,0) + v*DCN(i+1,1);
516  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
517  }
518 
519  /* remaining linear de Casteljau steps until the second last step */
520  for(h=minorder; h<uorder-1; h++)
521  for(i=0; i<uorder-h; i++)
522  {
523  /* for the derivative in v */
524  DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
525 
526  /* for the `point' */
527  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
528  }
529 
530  /* derivative direction in u */
531  du[k] = DCN(1,0) - DCN(0,0);
532 
533  /* derivative direction in v */
534  dv[k] = us*DCN(0,2) + u*DCN(1,2);
535 
536  /* last linear de Casteljau step */
537  out[k] = us*DCN(0,0) + u*DCN(1,0);
538  }
539  }
540 #undef DCN
541 #undef CN
542 }
543 
544 /*
545  * Return the number of components per control point for any type of
546  * evaluator. Return 0 if bad target.
547  */
548 
550 {
551  switch (target) {
552  case GL_MAP1_VERTEX_3: return 3;
553  case GL_MAP1_VERTEX_4: return 4;
554  case GL_MAP1_INDEX: return 1;
555  case GL_MAP1_COLOR_4: return 4;
556  case GL_MAP1_NORMAL: return 3;
557  case GL_MAP1_TEXTURE_COORD_1: return 1;
558  case GL_MAP1_TEXTURE_COORD_2: return 2;
559  case GL_MAP1_TEXTURE_COORD_3: return 3;
560  case GL_MAP1_TEXTURE_COORD_4: return 4;
561  case GL_MAP2_VERTEX_3: return 3;
562  case GL_MAP2_VERTEX_4: return 4;
563  case GL_MAP2_INDEX: return 1;
564  case GL_MAP2_COLOR_4: return 4;
565  case GL_MAP2_NORMAL: return 3;
566  case GL_MAP2_TEXTURE_COORD_1: return 1;
567  case GL_MAP2_TEXTURE_COORD_2: return 2;
568  case GL_MAP2_TEXTURE_COORD_3: return 3;
569  case GL_MAP2_TEXTURE_COORD_4: return 4;
570  default: return 0;
571  }
572 }
573 
574 
575 /**********************************************************************/
576 /*** Copy and deallocate control points ***/
577 /**********************************************************************/
578 
579 
580 /*
581  * Copy 1-parametric evaluator control points from user-specified
582  * memory space to a buffer of contiguous control points.
583  * Input: see glMap1f for details
584  * Return: pointer to buffer of contiguous control points or NULL if out
585  * of memory.
586  */
589  const GLfloat *points )
590 {
591  GLfloat *buffer, *p;
593 
594  if (!points || size==0) {
595  return NULL;
596  }
597 
598  buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
599 
600  if(buffer)
601  for(i=0, p=buffer; i<uorder; i++, points+=ustride)
602  for(k=0; k<size; k++)
603  *p++ = points[k];
604 
605  return buffer;
606 }
607 
608 
609 
610 /*
611  * Same as above but convert doubles to floats.
612  */
615  const GLdouble *points )
616 {
617  GLfloat *buffer, *p;
619 
620  if (!points || size==0) {
621  return NULL;
622  }
623 
624  buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
625 
626  if(buffer)
627  for(i=0, p=buffer; i<uorder; i++, points+=ustride)
628  for(k=0; k<size; k++)
629  *p++ = (GLfloat) points[k];
630 
631  return buffer;
632 }
633 
634 
635 
636 /*
637  * Copy 2-parametric evaluator control points from user-specified
638  * memory space to a buffer of contiguous control points.
639  * Additional memory is allocated to be used by the horner and
640  * de Casteljau evaluation schemes.
641  *
642  * Input: see glMap2f for details
643  * Return: pointer to buffer of contiguous control points or NULL if out
644  * of memory.
645  */
649  const GLfloat *points )
650 {
651  GLfloat *buffer, *p;
652  GLuint i, j, k, size, dsize, hsize;
653  GLint uinc;
654 
656 
657  if (!points || size==0) {
658  return NULL;
659  }
660 
661  /* max(uorder, vorder) additional points are used in */
662  /* horner evaluation and uorder*vorder additional */
663  /* values are needed for de Casteljau */
664  dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
665  hsize = (uorder > vorder ? uorder : vorder)*size;
666 
667  if(hsize>dsize)
668  buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
669  else
670  buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
671 
672  /* compute the increment value for the u-loop */
673  uinc = ustride - vorder*vstride;
674 
675  if (buffer)
676  for (i=0, p=buffer; i<uorder; i++, points += uinc)
677  for (j=0; j<vorder; j++, points += vstride)
678  for (k=0; k<size; k++)
679  *p++ = points[k];
680 
681  return buffer;
682 }
683 
684 
685 
686 /*
687  * Same as above but convert doubles to floats.
688  */
692  const GLdouble *points )
693 {
694  GLfloat *buffer, *p;
695  GLuint i, j, k, size, hsize, dsize;
696  GLint uinc;
697 
699 
700  if (!points || size==0) {
701  return NULL;
702  }
703 
704  /* max(uorder, vorder) additional points are used in */
705  /* horner evaluation and uorder*vorder additional */
706  /* values are needed for de Casteljau */
707  dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
708  hsize = (uorder > vorder ? uorder : vorder)*size;
709 
710  if(hsize>dsize)
711  buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
712  else
713  buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
714 
715  /* compute the increment value for the u-loop */
716  uinc = ustride - vorder*vstride;
717 
718  if (buffer)
719  for (i=0, p=buffer; i<uorder; i++, points += uinc)
720  for (j=0; j<vorder; j++, points += vstride)
721  for (k=0; k<size; k++)
722  *p++ = (GLfloat) points[k];
723 
724  return buffer;
725 }
726 
727 
728 /*
729  * This function is called by the display list deallocator function to
730  * specify that a given set of control points are no longer needed.
731  */
733 {
734  struct gl_1d_map *map1 = NULL;
735  struct gl_2d_map *map2 = NULL;
736 
737  switch (target) {
738  case GL_MAP1_VERTEX_3:
739  map1 = &ctx->EvalMap.Map1Vertex3;
740  break;
741  case GL_MAP1_VERTEX_4:
742  map1 = &ctx->EvalMap.Map1Vertex4;
743  break;
744  case GL_MAP1_INDEX:
745  map1 = &ctx->EvalMap.Map1Index;
746  break;
747  case GL_MAP1_COLOR_4:
748  map1 = &ctx->EvalMap.Map1Color4;
749  break;
750  case GL_MAP1_NORMAL:
751  map1 = &ctx->EvalMap.Map1Normal;
752  break;
754  map1 = &ctx->EvalMap.Map1Texture1;
755  break;
757  map1 = &ctx->EvalMap.Map1Texture2;
758  break;
760  map1 = &ctx->EvalMap.Map1Texture3;
761  break;
763  map1 = &ctx->EvalMap.Map1Texture4;
764  break;
765  case GL_MAP2_VERTEX_3:
766  map2 = &ctx->EvalMap.Map2Vertex3;
767  break;
768  case GL_MAP2_VERTEX_4:
769  map2 = &ctx->EvalMap.Map2Vertex4;
770  break;
771  case GL_MAP2_INDEX:
772  map2 = &ctx->EvalMap.Map2Index;
773  break;
774  case GL_MAP2_COLOR_4:
775  map2 = &ctx->EvalMap.Map2Color4;
776  break;
777  case GL_MAP2_NORMAL:
778  map2 = &ctx->EvalMap.Map2Normal;
779  break;
781  map2 = &ctx->EvalMap.Map2Texture1;
782  break;
784  map2 = &ctx->EvalMap.Map2Texture2;
785  break;
787  map2 = &ctx->EvalMap.Map2Texture3;
788  break;
790  map2 = &ctx->EvalMap.Map2Texture4;
791  break;
792  default:
793  gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
794  return;
795  }
796 
797  if (map1) {
798  if (data==map1->Points) {
799  /* The control points in the display list are currently */
800  /* being used so we can mark them as discard-able. */
801  map1->Retain = GL_FALSE;
802  }
803  else {
804  /* The control points in the display list are not currently */
805  /* being used. */
806  free( data );
807  }
808  }
809  if (map2) {
810  if (data==map2->Points) {
811  /* The control points in the display list are currently */
812  /* being used so we can mark them as discard-able. */
813  map2->Retain = GL_FALSE;
814  }
815  else {
816  /* The control points in the display list are not currently */
817  /* being used. */
818  free( data );
819  }
820  }
821 
822 }
823 
824 
825 
826 /**********************************************************************/
827 /*** API entry points ***/
828 /**********************************************************************/
829 
830 
831 /*
832  * Note that the array of control points must be 'unpacked' at this time.
833  * Input: retain - if TRUE, this control point data is also in a display
834  * list and can't be freed until the list is freed.
835  */
838  GLint order, const GLfloat *points, GLboolean retain )
839 {
840  GLuint k;
841 
842  if (!points) {
843  gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
844  return;
845  }
846 
847  /* may be a new stride after copying control points */
848  stride = components( target );
849 
850  if (INSIDE_BEGIN_END(ctx)) {
851  gl_error( ctx, GL_INVALID_OPERATION, "glMap1" );
852  return;
853  }
854 
855  if (u1==u2) {
856  gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
857  return;
858  }
859 
861  gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
862  return;
863  }
864 
865  k = components( target );
866  if (k==0) {
867  gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
868  }
869 
870  if (stride < k) {
871  gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
872  return;
873  }
874 
875  switch (target) {
876  case GL_MAP1_VERTEX_3:
877  ctx->EvalMap.Map1Vertex3.Order = order;
878  ctx->EvalMap.Map1Vertex3.u1 = u1;
879  ctx->EvalMap.Map1Vertex3.u2 = u2;
880  if (ctx->EvalMap.Map1Vertex3.Points
881  && !ctx->EvalMap.Map1Vertex3.Retain) {
882  free( ctx->EvalMap.Map1Vertex3.Points );
883  }
884  ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
885  ctx->EvalMap.Map1Vertex3.Retain = retain;
886  break;
887  case GL_MAP1_VERTEX_4:
888  ctx->EvalMap.Map1Vertex4.Order = order;
889  ctx->EvalMap.Map1Vertex4.u1 = u1;
890  ctx->EvalMap.Map1Vertex4.u2 = u2;
891  if (ctx->EvalMap.Map1Vertex4.Points
892  && !ctx->EvalMap.Map1Vertex4.Retain) {
893  free( ctx->EvalMap.Map1Vertex4.Points );
894  }
895  ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
896  ctx->EvalMap.Map1Vertex4.Retain = retain;
897  break;
898  case GL_MAP1_INDEX:
899  ctx->EvalMap.Map1Index.Order = order;
900  ctx->EvalMap.Map1Index.u1 = u1;
901  ctx->EvalMap.Map1Index.u2 = u2;
902  if (ctx->EvalMap.Map1Index.Points
903  && !ctx->EvalMap.Map1Index.Retain) {
904  free( ctx->EvalMap.Map1Index.Points );
905  }
906  ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
907  ctx->EvalMap.Map1Index.Retain = retain;
908  break;
909  case GL_MAP1_COLOR_4:
910  ctx->EvalMap.Map1Color4.Order = order;
911  ctx->EvalMap.Map1Color4.u1 = u1;
912  ctx->EvalMap.Map1Color4.u2 = u2;
913  if (ctx->EvalMap.Map1Color4.Points
914  && !ctx->EvalMap.Map1Color4.Retain) {
915  free( ctx->EvalMap.Map1Color4.Points );
916  }
917  ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
918  ctx->EvalMap.Map1Color4.Retain = retain;
919  break;
920  case GL_MAP1_NORMAL:
921  ctx->EvalMap.Map1Normal.Order = order;
922  ctx->EvalMap.Map1Normal.u1 = u1;
923  ctx->EvalMap.Map1Normal.u2 = u2;
924  if (ctx->EvalMap.Map1Normal.Points
925  && !ctx->EvalMap.Map1Normal.Retain) {
926  free( ctx->EvalMap.Map1Normal.Points );
927  }
928  ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
929  ctx->EvalMap.Map1Normal.Retain = retain;
930  break;
932  ctx->EvalMap.Map1Texture1.Order = order;
933  ctx->EvalMap.Map1Texture1.u1 = u1;
934  ctx->EvalMap.Map1Texture1.u2 = u2;
935  if (ctx->EvalMap.Map1Texture1.Points
936  && !ctx->EvalMap.Map1Texture1.Retain) {
937  free( ctx->EvalMap.Map1Texture1.Points );
938  }
939  ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
940  ctx->EvalMap.Map1Texture1.Retain = retain;
941  break;
943  ctx->EvalMap.Map1Texture2.Order = order;
944  ctx->EvalMap.Map1Texture2.u1 = u1;
945  ctx->EvalMap.Map1Texture2.u2 = u2;
946  if (ctx->EvalMap.Map1Texture2.Points
947  && !ctx->EvalMap.Map1Texture2.Retain) {
948  free( ctx->EvalMap.Map1Texture2.Points );
949  }
950  ctx->EvalMap.Map1Texture2.Points = (GLfloat *) points;
951  ctx->EvalMap.Map1Texture2.Retain = retain;
952  break;
954  ctx->EvalMap.Map1Texture3.Order = order;
955  ctx->EvalMap.Map1Texture3.u1 = u1;
956  ctx->EvalMap.Map1Texture3.u2 = u2;
957  if (ctx->EvalMap.Map1Texture3.Points
958  && !ctx->EvalMap.Map1Texture3.Retain) {
959  free( ctx->EvalMap.Map1Texture3.Points );
960  }
961  ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
962  ctx->EvalMap.Map1Texture3.Retain = retain;
963  break;
965  ctx->EvalMap.Map1Texture4.Order = order;
966  ctx->EvalMap.Map1Texture4.u1 = u1;
967  ctx->EvalMap.Map1Texture4.u2 = u2;
968  if (ctx->EvalMap.Map1Texture4.Points
969  && !ctx->EvalMap.Map1Texture4.Retain) {
970  free( ctx->EvalMap.Map1Texture4.Points );
971  }
972  ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
973  ctx->EvalMap.Map1Texture4.Retain = retain;
974  break;
975  default:
976  gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
977  }
978 }
979 
980 
981 
982 
983 /*
984  * Note that the array of control points must be 'unpacked' at this time.
985  * Input: retain - if TRUE, this control point data is also in a display
986  * list and can't be freed until the list is freed.
987  */
991  const GLfloat *points, GLboolean retain )
992 {
993  GLuint k;
994 
995  if (INSIDE_BEGIN_END(ctx)) {
996  gl_error( ctx, GL_INVALID_OPERATION, "glMap2" );
997  return;
998  }
999 
1000  if (u1==u2) {
1001  gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
1002  return;
1003  }
1004 
1005  if (v1==v2) {
1006  gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
1007  return;
1008  }
1009 
1011  gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
1012  return;
1013  }
1014 
1016  gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
1017  return;
1018  }
1019 
1020  k = components( target );
1021  if (k==0) {
1022  gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
1023  }
1024 
1025  if (ustride < k) {
1026  gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
1027  return;
1028  }
1029  if (vstride < k) {
1030  gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
1031  return;
1032  }
1033 
1034  switch (target) {
1035  case GL_MAP2_VERTEX_3:
1036  ctx->EvalMap.Map2Vertex3.Uorder = uorder;
1037  ctx->EvalMap.Map2Vertex3.u1 = u1;
1038  ctx->EvalMap.Map2Vertex3.u2 = u2;
1039  ctx->EvalMap.Map2Vertex3.Vorder = vorder;
1040  ctx->EvalMap.Map2Vertex3.v1 = v1;
1041  ctx->EvalMap.Map2Vertex3.v2 = v2;
1042  if (ctx->EvalMap.Map2Vertex3.Points
1043  && !ctx->EvalMap.Map2Vertex3.Retain) {
1044  free( ctx->EvalMap.Map2Vertex3.Points );
1045  }
1046  ctx->EvalMap.Map2Vertex3.Retain = retain;
1047  ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
1048  break;
1049  case GL_MAP2_VERTEX_4:
1050  ctx->EvalMap.Map2Vertex4.Uorder = uorder;
1051  ctx->EvalMap.Map2Vertex4.u1 = u1;
1052  ctx->EvalMap.Map2Vertex4.u2 = u2;
1053  ctx->EvalMap.Map2Vertex4.Vorder = vorder;
1054  ctx->EvalMap.Map2Vertex4.v1 = v1;
1055  ctx->EvalMap.Map2Vertex4.v2 = v2;
1056  if (ctx->EvalMap.Map2Vertex4.Points
1057  && !ctx->EvalMap.Map2Vertex4.Retain) {
1058  free( ctx->EvalMap.Map2Vertex4.Points );
1059  }
1060  ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
1061  ctx->EvalMap.Map2Vertex4.Retain = retain;
1062  break;
1063  case GL_MAP2_INDEX:
1064  ctx->EvalMap.Map2Index.Uorder = uorder;
1065  ctx->EvalMap.Map2Index.u1 = u1;
1066  ctx->EvalMap.Map2Index.u2 = u2;
1067  ctx->EvalMap.Map2Index.Vorder = vorder;
1068  ctx->EvalMap.Map2Index.v1 = v1;
1069  ctx->EvalMap.Map2Index.v2 = v2;
1070  if (ctx->EvalMap.Map2Index.Points
1071  && !ctx->EvalMap.Map2Index.Retain) {
1072  free( ctx->EvalMap.Map2Index.Points );
1073  }
1074  ctx->EvalMap.Map2Index.Retain = retain;
1075  ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
1076  break;
1077  case GL_MAP2_COLOR_4:
1078  ctx->EvalMap.Map2Color4.Uorder = uorder;
1079  ctx->EvalMap.Map2Color4.u1 = u1;
1080  ctx->EvalMap.Map2Color4.u2 = u2;
1081  ctx->EvalMap.Map2Color4.Vorder = vorder;
1082  ctx->EvalMap.Map2Color4.v1 = v1;
1083  ctx->EvalMap.Map2Color4.v2 = v2;
1084  if (ctx->EvalMap.Map2Color4.Points
1085  && !ctx->EvalMap.Map2Color4.Retain) {
1086  free( ctx->EvalMap.Map2Color4.Points );
1087  }
1088  ctx->EvalMap.Map2Color4.Retain = retain;
1089  ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
1090  break;
1091  case GL_MAP2_NORMAL:
1092  ctx->EvalMap.Map2Normal.Uorder = uorder;
1093  ctx->EvalMap.Map2Normal.u1 = u1;
1094  ctx->EvalMap.Map2Normal.u2 = u2;
1095  ctx->EvalMap.Map2Normal.Vorder = vorder;
1096  ctx->EvalMap.Map2Normal.v1 = v1;
1097  ctx->EvalMap.Map2Normal.v2 = v2;
1098  if (ctx->EvalMap.Map2Normal.Points
1099  && !ctx->EvalMap.Map2Normal.Retain) {
1100  free( ctx->EvalMap.Map2Normal.Points );
1101  }
1102  ctx->EvalMap.Map2Normal.Retain = retain;
1103  ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
1104  break;
1106  ctx->EvalMap.Map2Texture1.Uorder = uorder;
1107  ctx->EvalMap.Map2Texture1.u1 = u1;
1108  ctx->EvalMap.Map2Texture1.u2 = u2;
1109  ctx->EvalMap.Map2Texture1.Vorder = vorder;
1110  ctx->EvalMap.Map2Texture1.v1 = v1;
1111  ctx->EvalMap.Map2Texture1.v2 = v2;
1112  if (ctx->EvalMap.Map2Texture1.Points
1113  && !ctx->EvalMap.Map2Texture1.Retain) {
1114  free( ctx->EvalMap.Map2Texture1.Points );
1115  }
1116  ctx->EvalMap.Map2Texture1.Retain = retain;
1117  ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
1118  break;
1120  ctx->EvalMap.Map2Texture2.Uorder = uorder;
1121  ctx->EvalMap.Map2Texture2.u1 = u1;
1122  ctx->EvalMap.Map2Texture2.u2 = u2;
1123  ctx->EvalMap.Map2Texture2.Vorder = vorder;
1124  ctx->EvalMap.Map2Texture2.v1 = v1;
1125  ctx->EvalMap.Map2Texture2.v2 = v2;
1126  if (ctx->EvalMap.Map2Texture2.Points
1127  && !ctx->EvalMap.Map2Texture2.Retain) {
1128  free( ctx->EvalMap.Map2Texture2.Points );
1129  }
1130  ctx->EvalMap.Map2Texture2.Retain = retain;
1131  ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
1132  break;
1134  ctx->EvalMap.Map2Texture3.Uorder = uorder;
1135  ctx->EvalMap.Map2Texture3.u1 = u1;
1136  ctx->EvalMap.Map2Texture3.u2 = u2;
1137  ctx->EvalMap.Map2Texture3.Vorder = vorder;
1138  ctx->EvalMap.Map2Texture3.v1 = v1;
1139  ctx->EvalMap.Map2Texture3.v2 = v2;
1140  if (ctx->EvalMap.Map2Texture3.Points
1141  && !ctx->EvalMap.Map2Texture3.Retain) {
1142  free( ctx->EvalMap.Map2Texture3.Points );
1143  }
1144  ctx->EvalMap.Map2Texture3.Retain = retain;
1145  ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
1146  break;
1148  ctx->EvalMap.Map2Texture4.Uorder = uorder;
1149  ctx->EvalMap.Map2Texture4.u1 = u1;
1150  ctx->EvalMap.Map2Texture4.u2 = u2;
1151  ctx->EvalMap.Map2Texture4.Vorder = vorder;
1152  ctx->EvalMap.Map2Texture4.v1 = v1;
1153  ctx->EvalMap.Map2Texture4.v2 = v2;
1154  if (ctx->EvalMap.Map2Texture4.Points
1155  && !ctx->EvalMap.Map2Texture4.Retain) {
1156  free( ctx->EvalMap.Map2Texture4.Points );
1157  }
1158  ctx->EvalMap.Map2Texture4.Retain = retain;
1159  ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
1160  break;
1161  default:
1162  gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
1163  }
1164 }
1165 
1166 
1167 
1168 
1169 
1171 {
1172  GLuint i, n;
1173  GLfloat *data;
1174 
1175  switch (query) {
1176  case GL_COEFF:
1177  switch (target) {
1178  case GL_MAP1_COLOR_4:
1179  data = ctx->EvalMap.Map1Color4.Points;
1180  n = ctx->EvalMap.Map1Color4.Order * 4;
1181  break;
1182  case GL_MAP1_INDEX:
1183  data = ctx->EvalMap.Map1Index.Points;
1184  n = ctx->EvalMap.Map1Index.Order;
1185  break;
1186  case GL_MAP1_NORMAL:
1187  data = ctx->EvalMap.Map1Normal.Points;
1188  n = ctx->EvalMap.Map1Normal.Order * 3;
1189  break;
1191  data = ctx->EvalMap.Map1Texture1.Points;
1192  n = ctx->EvalMap.Map1Texture1.Order * 1;
1193  break;
1195  data = ctx->EvalMap.Map1Texture2.Points;
1196  n = ctx->EvalMap.Map1Texture2.Order * 2;
1197  break;
1199  data = ctx->EvalMap.Map1Texture3.Points;
1200  n = ctx->EvalMap.Map1Texture3.Order * 3;
1201  break;
1203  data = ctx->EvalMap.Map1Texture4.Points;
1204  n = ctx->EvalMap.Map1Texture4.Order * 4;
1205  break;
1206  case GL_MAP1_VERTEX_3:
1207  data = ctx->EvalMap.Map1Vertex3.Points;
1208  n = ctx->EvalMap.Map1Vertex3.Order * 3;
1209  break;
1210  case GL_MAP1_VERTEX_4:
1211  data = ctx->EvalMap.Map1Vertex4.Points;
1212  n = ctx->EvalMap.Map1Vertex4.Order * 4;
1213  break;
1214  case GL_MAP2_COLOR_4:
1215  data = ctx->EvalMap.Map2Color4.Points;
1216  n = ctx->EvalMap.Map2Color4.Uorder
1217  * ctx->EvalMap.Map2Color4.Vorder * 4;
1218  break;
1219  case GL_MAP2_INDEX:
1220  data = ctx->EvalMap.Map2Index.Points;
1221  n = ctx->EvalMap.Map2Index.Uorder
1222  * ctx->EvalMap.Map2Index.Vorder;
1223  break;
1224  case GL_MAP2_NORMAL:
1225  data = ctx->EvalMap.Map2Normal.Points;
1226  n = ctx->EvalMap.Map2Normal.Uorder
1227  * ctx->EvalMap.Map2Normal.Vorder * 3;
1228  break;
1230  data = ctx->EvalMap.Map2Texture1.Points;
1231  n = ctx->EvalMap.Map2Texture1.Uorder
1232  * ctx->EvalMap.Map2Texture1.Vorder * 1;
1233  break;
1235  data = ctx->EvalMap.Map2Texture2.Points;
1236  n = ctx->EvalMap.Map2Texture2.Uorder
1237  * ctx->EvalMap.Map2Texture2.Vorder * 2;
1238  break;
1240  data = ctx->EvalMap.Map2Texture3.Points;
1241  n = ctx->EvalMap.Map2Texture3.Uorder
1242  * ctx->EvalMap.Map2Texture3.Vorder * 3;
1243  break;
1245  data = ctx->EvalMap.Map2Texture4.Points;
1246  n = ctx->EvalMap.Map2Texture4.Uorder
1247  * ctx->EvalMap.Map2Texture4.Vorder * 4;
1248  break;
1249  case GL_MAP2_VERTEX_3:
1250  data = ctx->EvalMap.Map2Vertex3.Points;
1251  n = ctx->EvalMap.Map2Vertex3.Uorder
1252  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1253  break;
1254  case GL_MAP2_VERTEX_4:
1255  data = ctx->EvalMap.Map2Vertex4.Points;
1256  n = ctx->EvalMap.Map2Vertex4.Uorder
1257  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1258  break;
1259  default:
1260  gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1261  }
1262  if (data) {
1263  for (i=0;i<n;i++) {
1264  v[i] = data[i];
1265  }
1266  }
1267  break;
1268  case GL_ORDER:
1269  switch (target) {
1270  case GL_MAP1_COLOR_4:
1271  *v = ctx->EvalMap.Map1Color4.Order;
1272  break;
1273  case GL_MAP1_INDEX:
1274  *v = ctx->EvalMap.Map1Index.Order;
1275  break;
1276  case GL_MAP1_NORMAL:
1277  *v = ctx->EvalMap.Map1Normal.Order;
1278  break;
1280  *v = ctx->EvalMap.Map1Texture1.Order;
1281  break;
1283  *v = ctx->EvalMap.Map1Texture2.Order;
1284  break;
1286  *v = ctx->EvalMap.Map1Texture3.Order;
1287  break;
1289  *v = ctx->EvalMap.Map1Texture4.Order;
1290  break;
1291  case GL_MAP1_VERTEX_3:
1292  *v = ctx->EvalMap.Map1Vertex3.Order;
1293  break;
1294  case GL_MAP1_VERTEX_4:
1295  *v = ctx->EvalMap.Map1Vertex4.Order;
1296  break;
1297  case GL_MAP2_COLOR_4:
1298  v[0] = ctx->EvalMap.Map2Color4.Uorder;
1299  v[1] = ctx->EvalMap.Map2Color4.Vorder;
1300  break;
1301  case GL_MAP2_INDEX:
1302  v[0] = ctx->EvalMap.Map2Index.Uorder;
1303  v[1] = ctx->EvalMap.Map2Index.Vorder;
1304  break;
1305  case GL_MAP2_NORMAL:
1306  v[0] = ctx->EvalMap.Map2Normal.Uorder;
1307  v[1] = ctx->EvalMap.Map2Normal.Vorder;
1308  break;
1310  v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1311  v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1312  break;
1314  v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1315  v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1316  break;
1318  v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1319  v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1320  break;
1322  v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1323  v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1324  break;
1325  case GL_MAP2_VERTEX_3:
1326  v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1327  v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1328  break;
1329  case GL_MAP2_VERTEX_4:
1330  v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1331  v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1332  break;
1333  default:
1334  gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1335  }
1336  break;
1337  case GL_DOMAIN:
1338  switch (target) {
1339  case GL_MAP1_COLOR_4:
1340  v[0] = ctx->EvalMap.Map1Color4.u1;
1341  v[1] = ctx->EvalMap.Map1Color4.u2;
1342  break;
1343  case GL_MAP1_INDEX:
1344  v[0] = ctx->EvalMap.Map1Index.u1;
1345  v[1] = ctx->EvalMap.Map1Index.u2;
1346  break;
1347  case GL_MAP1_NORMAL:
1348  v[0] = ctx->EvalMap.Map1Normal.u1;
1349  v[1] = ctx->EvalMap.Map1Normal.u2;
1350  break;
1352  v[0] = ctx->EvalMap.Map1Texture1.u1;
1353  v[1] = ctx->EvalMap.Map1Texture1.u2;
1354  break;
1356  v[0] = ctx->EvalMap.Map1Texture2.u1;
1357  v[1] = ctx->EvalMap.Map1Texture2.u2;
1358  break;
1360  v[0] = ctx->EvalMap.Map1Texture3.u1;
1361  v[1] = ctx->EvalMap.Map1Texture3.u2;
1362  break;
1364  v[0] = ctx->EvalMap.Map1Texture4.u1;
1365  v[1] = ctx->EvalMap.Map1Texture4.u2;
1366  break;
1367  case GL_MAP1_VERTEX_3:
1368  v[0] = ctx->EvalMap.Map1Vertex3.u1;
1369  v[1] = ctx->EvalMap.Map1Vertex3.u2;
1370  break;
1371  case GL_MAP1_VERTEX_4:
1372  v[0] = ctx->EvalMap.Map1Vertex4.u1;
1373  v[1] = ctx->EvalMap.Map1Vertex4.u2;
1374  break;
1375  case GL_MAP2_COLOR_4:
1376  v[0] = ctx->EvalMap.Map2Color4.u1;
1377  v[1] = ctx->EvalMap.Map2Color4.u2;
1378  v[2] = ctx->EvalMap.Map2Color4.v1;
1379  v[3] = ctx->EvalMap.Map2Color4.v2;
1380  break;
1381  case GL_MAP2_INDEX:
1382  v[0] = ctx->EvalMap.Map2Index.u1;
1383  v[1] = ctx->EvalMap.Map2Index.u2;
1384  v[2] = ctx->EvalMap.Map2Index.v1;
1385  v[3] = ctx->EvalMap.Map2Index.v2;
1386  break;
1387  case GL_MAP2_NORMAL:
1388  v[0] = ctx->EvalMap.Map2Normal.u1;
1389  v[1] = ctx->EvalMap.Map2Normal.u2;
1390  v[2] = ctx->EvalMap.Map2Normal.v1;
1391  v[3] = ctx->EvalMap.Map2Normal.v2;
1392  break;
1394  v[0] = ctx->EvalMap.Map2Texture1.u1;
1395  v[1] = ctx->EvalMap.Map2Texture1.u2;
1396  v[2] = ctx->EvalMap.Map2Texture1.v1;
1397  v[3] = ctx->EvalMap.Map2Texture1.v2;
1398  break;
1400  v[0] = ctx->EvalMap.Map2Texture2.u1;
1401  v[1] = ctx->EvalMap.Map2Texture2.u2;
1402  v[2] = ctx->EvalMap.Map2Texture2.v1;
1403  v[3] = ctx->EvalMap.Map2Texture2.v2;
1404  break;
1406  v[0] = ctx->EvalMap.Map2Texture3.u1;
1407  v[1] = ctx->EvalMap.Map2Texture3.u2;
1408  v[2] = ctx->EvalMap.Map2Texture3.v1;
1409  v[3] = ctx->EvalMap.Map2Texture3.v2;
1410  break;
1412  v[0] = ctx->EvalMap.Map2Texture4.u1;
1413  v[1] = ctx->EvalMap.Map2Texture4.u2;
1414  v[2] = ctx->EvalMap.Map2Texture4.v1;
1415  v[3] = ctx->EvalMap.Map2Texture4.v2;
1416  break;
1417  case GL_MAP2_VERTEX_3:
1418  v[0] = ctx->EvalMap.Map2Vertex3.u1;
1419  v[1] = ctx->EvalMap.Map2Vertex3.u2;
1420  v[2] = ctx->EvalMap.Map2Vertex3.v1;
1421  v[3] = ctx->EvalMap.Map2Vertex3.v2;
1422  break;
1423  case GL_MAP2_VERTEX_4:
1424  v[0] = ctx->EvalMap.Map2Vertex4.u1;
1425  v[1] = ctx->EvalMap.Map2Vertex4.u2;
1426  v[2] = ctx->EvalMap.Map2Vertex4.v1;
1427  v[3] = ctx->EvalMap.Map2Vertex4.v2;
1428  break;
1429  default:
1430  gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1431  }
1432  break;
1433  default:
1434  gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
1435  }
1436 }
1437 
1438 
1440 {
1441  GLuint i, n;
1442  GLfloat *data;
1443 
1444  switch (query) {
1445  case GL_COEFF:
1446  switch (target) {
1447  case GL_MAP1_COLOR_4:
1448  data = ctx->EvalMap.Map1Color4.Points;
1449  n = ctx->EvalMap.Map1Color4.Order * 4;
1450  break;
1451  case GL_MAP1_INDEX:
1452  data = ctx->EvalMap.Map1Index.Points;
1453  n = ctx->EvalMap.Map1Index.Order;
1454  break;
1455  case GL_MAP1_NORMAL:
1456  data = ctx->EvalMap.Map1Normal.Points;
1457  n = ctx->EvalMap.Map1Normal.Order * 3;
1458  break;
1460  data = ctx->EvalMap.Map1Texture1.Points;
1461  n = ctx->EvalMap.Map1Texture1.Order * 1;
1462  break;
1464  data = ctx->EvalMap.Map1Texture2.Points;
1465  n = ctx->EvalMap.Map1Texture2.Order * 2;
1466  break;
1468  data = ctx->EvalMap.Map1Texture3.Points;
1469  n = ctx->EvalMap.Map1Texture3.Order * 3;
1470  break;
1472  data = ctx->EvalMap.Map1Texture4.Points;
1473  n = ctx->EvalMap.Map1Texture4.Order * 4;
1474  break;
1475  case GL_MAP1_VERTEX_3:
1476  data = ctx->EvalMap.Map1Vertex3.Points;
1477  n = ctx->EvalMap.Map1Vertex3.Order * 3;
1478  break;
1479  case GL_MAP1_VERTEX_4:
1480  data = ctx->EvalMap.Map1Vertex4.Points;
1481  n = ctx->EvalMap.Map1Vertex4.Order * 4;
1482  break;
1483  case GL_MAP2_COLOR_4:
1484  data = ctx->EvalMap.Map2Color4.Points;
1485  n = ctx->EvalMap.Map2Color4.Uorder
1486  * ctx->EvalMap.Map2Color4.Vorder * 4;
1487  break;
1488  case GL_MAP2_INDEX:
1489  data = ctx->EvalMap.Map2Index.Points;
1490  n = ctx->EvalMap.Map2Index.Uorder
1491  * ctx->EvalMap.Map2Index.Vorder;
1492  break;
1493  case GL_MAP2_NORMAL:
1494  data = ctx->EvalMap.Map2Normal.Points;
1495  n = ctx->EvalMap.Map2Normal.Uorder
1496  * ctx->EvalMap.Map2Normal.Vorder * 3;
1497  break;
1499  data = ctx->EvalMap.Map2Texture1.Points;
1500  n = ctx->EvalMap.Map2Texture1.Uorder
1501  * ctx->EvalMap.Map2Texture1.Vorder * 1;
1502  break;
1504  data = ctx->EvalMap.Map2Texture2.Points;
1505  n = ctx->EvalMap.Map2Texture2.Uorder
1506  * ctx->EvalMap.Map2Texture2.Vorder * 2;
1507  break;
1509  data = ctx->EvalMap.Map2Texture3.Points;
1510  n = ctx->EvalMap.Map2Texture3.Uorder
1511  * ctx->EvalMap.Map2Texture3.Vorder * 3;
1512  break;
1514  data = ctx->EvalMap.Map2Texture4.Points;
1515  n = ctx->EvalMap.Map2Texture4.Uorder
1516  * ctx->EvalMap.Map2Texture4.Vorder * 4;
1517  break;
1518  case GL_MAP2_VERTEX_3:
1519  data = ctx->EvalMap.Map2Vertex3.Points;
1520  n = ctx->EvalMap.Map2Vertex3.Uorder
1521  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1522  break;
1523  case GL_MAP2_VERTEX_4:
1524  data = ctx->EvalMap.Map2Vertex4.Points;
1525  n = ctx->EvalMap.Map2Vertex4.Uorder
1526  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1527  break;
1528  default:
1529  gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1530  }
1531  if (data) {
1532  for (i=0;i<n;i++) {
1533  v[i] = data[i];
1534  }
1535  }
1536  break;
1537  case GL_ORDER:
1538  switch (target) {
1539  case GL_MAP1_COLOR_4:
1540  *v = ctx->EvalMap.Map1Color4.Order;
1541  break;
1542  case GL_MAP1_INDEX:
1543  *v = ctx->EvalMap.Map1Index.Order;
1544  break;
1545  case GL_MAP1_NORMAL:
1546  *v = ctx->EvalMap.Map1Normal.Order;
1547  break;
1549  *v = ctx->EvalMap.Map1Texture1.Order;
1550  break;
1552  *v = ctx->EvalMap.Map1Texture2.Order;
1553  break;
1555  *v = ctx->EvalMap.Map1Texture3.Order;
1556  break;
1558  *v = ctx->EvalMap.Map1Texture4.Order;
1559  break;
1560  case GL_MAP1_VERTEX_3:
1561  *v = ctx->EvalMap.Map1Vertex3.Order;
1562  break;
1563  case GL_MAP1_VERTEX_4:
1564  *v = ctx->EvalMap.Map1Vertex4.Order;
1565  break;
1566  case GL_MAP2_COLOR_4:
1567  v[0] = ctx->EvalMap.Map2Color4.Uorder;
1568  v[1] = ctx->EvalMap.Map2Color4.Vorder;
1569  break;
1570  case GL_MAP2_INDEX:
1571  v[0] = ctx->EvalMap.Map2Index.Uorder;
1572  v[1] = ctx->EvalMap.Map2Index.Vorder;
1573  break;
1574  case GL_MAP2_NORMAL:
1575  v[0] = ctx->EvalMap.Map2Normal.Uorder;
1576  v[1] = ctx->EvalMap.Map2Normal.Vorder;
1577  break;
1579  v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1580  v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1581  break;
1583  v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1584  v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1585  break;
1587  v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1588  v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1589  break;
1591  v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1592  v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1593  break;
1594  case GL_MAP2_VERTEX_3:
1595  v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1596  v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1597  break;
1598  case GL_MAP2_VERTEX_4:
1599  v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1600  v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1601  break;
1602  default:
1603  gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1604  }
1605  break;
1606  case GL_DOMAIN:
1607  switch (target) {
1608  case GL_MAP1_COLOR_4:
1609  v[0] = ctx->EvalMap.Map1Color4.u1;
1610  v[1] = ctx->EvalMap.Map1Color4.u2;
1611  break;
1612  case GL_MAP1_INDEX:
1613  v[0] = ctx->EvalMap.Map1Index.u1;
1614  v[1] = ctx->EvalMap.Map1Index.u2;
1615  break;
1616  case GL_MAP1_NORMAL:
1617  v[0] = ctx->EvalMap.Map1Normal.u1;
1618  v[1] = ctx->EvalMap.Map1Normal.u2;
1619  break;
1621  v[0] = ctx->EvalMap.Map1Texture1.u1;
1622  v[1] = ctx->EvalMap.Map1Texture1.u2;
1623  break;
1625  v[0] = ctx->EvalMap.Map1Texture2.u1;
1626  v[1] = ctx->EvalMap.Map1Texture2.u2;
1627  break;
1629  v[0] = ctx->EvalMap.Map1Texture3.u1;
1630  v[1] = ctx->EvalMap.Map1Texture3.u2;
1631  break;
1633  v[0] = ctx->EvalMap.Map1Texture4.u1;
1634  v[1] = ctx->EvalMap.Map1Texture4.u2;
1635  break;
1636  case GL_MAP1_VERTEX_3:
1637  v[0] = ctx->EvalMap.Map1Vertex3.u1;
1638  v[1] = ctx->EvalMap.Map1Vertex3.u2;
1639  break;
1640  case GL_MAP1_VERTEX_4:
1641  v[0] = ctx->EvalMap.Map1Vertex4.u1;
1642  v[1] = ctx->EvalMap.Map1Vertex4.u2;
1643  break;
1644  case GL_MAP2_COLOR_4:
1645  v[0] = ctx->EvalMap.Map2Color4.u1;
1646  v[1] = ctx->EvalMap.Map2Color4.u2;
1647  v[2] = ctx->EvalMap.Map2Color4.v1;
1648  v[3] = ctx->EvalMap.Map2Color4.v2;
1649  break;
1650  case GL_MAP2_INDEX:
1651  v[0] = ctx->EvalMap.Map2Index.u1;
1652  v[1] = ctx->EvalMap.Map2Index.u2;
1653  v[2] = ctx->EvalMap.Map2Index.v1;
1654  v[3] = ctx->EvalMap.Map2Index.v2;
1655  break;
1656  case GL_MAP2_NORMAL:
1657  v[0] = ctx->EvalMap.Map2Normal.u1;
1658  v[1] = ctx->EvalMap.Map2Normal.u2;
1659  v[2] = ctx->EvalMap.Map2Normal.v1;
1660  v[3] = ctx->EvalMap.Map2Normal.v2;
1661  break;
1663  v[0] = ctx->EvalMap.Map2Texture1.u1;
1664  v[1] = ctx->EvalMap.Map2Texture1.u2;
1665  v[2] = ctx->EvalMap.Map2Texture1.v1;
1666  v[3] = ctx->EvalMap.Map2Texture1.v2;
1667  break;
1669  v[0] = ctx->EvalMap.Map2Texture2.u1;
1670  v[1] = ctx->EvalMap.Map2Texture2.u2;
1671  v[2] = ctx->EvalMap.Map2Texture2.v1;
1672  v[3] = ctx->EvalMap.Map2Texture2.v2;
1673  break;
1675  v[0] = ctx->EvalMap.Map2Texture3.u1;
1676  v[1] = ctx->EvalMap.Map2Texture3.u2;
1677  v[2] = ctx->EvalMap.Map2Texture3.v1;
1678  v[3] = ctx->EvalMap.Map2Texture3.v2;
1679  break;
1681  v[0] = ctx->EvalMap.Map2Texture4.u1;
1682  v[1] = ctx->EvalMap.Map2Texture4.u2;
1683  v[2] = ctx->EvalMap.Map2Texture4.v1;
1684  v[3] = ctx->EvalMap.Map2Texture4.v2;
1685  break;
1686  case GL_MAP2_VERTEX_3:
1687  v[0] = ctx->EvalMap.Map2Vertex3.u1;
1688  v[1] = ctx->EvalMap.Map2Vertex3.u2;
1689  v[2] = ctx->EvalMap.Map2Vertex3.v1;
1690  v[3] = ctx->EvalMap.Map2Vertex3.v2;
1691  break;
1692  case GL_MAP2_VERTEX_4:
1693  v[0] = ctx->EvalMap.Map2Vertex4.u1;
1694  v[1] = ctx->EvalMap.Map2Vertex4.u2;
1695  v[2] = ctx->EvalMap.Map2Vertex4.v1;
1696  v[3] = ctx->EvalMap.Map2Vertex4.v2;
1697  break;
1698  default:
1699  gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1700  }
1701  break;
1702  default:
1703  gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
1704  }
1705 }
1706 
1707 
1709 {
1710  GLuint i, n;
1711  GLfloat *data;
1712 
1713  switch (query) {
1714  case GL_COEFF:
1715  switch (target) {
1716  case GL_MAP1_COLOR_4:
1717  data = ctx->EvalMap.Map1Color4.Points;
1718  n = ctx->EvalMap.Map1Color4.Order * 4;
1719  break;
1720  case GL_MAP1_INDEX:
1721  data = ctx->EvalMap.Map1Index.Points;
1722  n = ctx->EvalMap.Map1Index.Order;
1723  break;
1724  case GL_MAP1_NORMAL:
1725  data = ctx->EvalMap.Map1Normal.Points;
1726  n = ctx->EvalMap.Map1Normal.Order * 3;
1727  break;
1729  data = ctx->EvalMap.Map1Texture1.Points;
1730  n = ctx->EvalMap.Map1Texture1.Order * 1;
1731  break;
1733  data = ctx->EvalMap.Map1Texture2.Points;
1734  n = ctx->EvalMap.Map1Texture2.Order * 2;
1735  break;
1737  data = ctx->EvalMap.Map1Texture3.Points;
1738  n = ctx->EvalMap.Map1Texture3.Order * 3;
1739  break;
1741  data = ctx->EvalMap.Map1Texture4.Points;
1742  n = ctx->EvalMap.Map1Texture4.Order * 4;
1743  break;
1744  case GL_MAP1_VERTEX_3:
1745  data = ctx->EvalMap.Map1Vertex3.Points;
1746  n = ctx->EvalMap.Map1Vertex3.Order * 3;
1747  break;
1748  case GL_MAP1_VERTEX_4:
1749  data = ctx->EvalMap.Map1Vertex4.Points;
1750  n = ctx->EvalMap.Map1Vertex4.Order * 4;
1751  break;
1752  case GL_MAP2_COLOR_4:
1753  data = ctx->EvalMap.Map2Color4.Points;
1754  n = ctx->EvalMap.Map2Color4.Uorder
1755  * ctx->EvalMap.Map2Color4.Vorder * 4;
1756  break;
1757  case GL_MAP2_INDEX:
1758  data = ctx->EvalMap.Map2Index.Points;
1759  n = ctx->EvalMap.Map2Index.Uorder
1760  * ctx->EvalMap.Map2Index.Vorder;
1761  break;
1762  case GL_MAP2_NORMAL:
1763  data = ctx->EvalMap.Map2Normal.Points;
1764  n = ctx->EvalMap.Map2Normal.Uorder
1765  * ctx->EvalMap.Map2Normal.Vorder * 3;
1766  break;
1768  data = ctx->EvalMap.Map2Texture1.Points;
1769  n = ctx->EvalMap.Map2Texture1.Uorder
1770  * ctx->EvalMap.Map2Texture1.Vorder * 1;
1771  break;
1773  data = ctx->EvalMap.Map2Texture2.Points;
1774  n = ctx->EvalMap.Map2Texture2.Uorder
1775  * ctx->EvalMap.Map2Texture2.Vorder * 2;
1776  break;
1778  data = ctx->EvalMap.Map2Texture3.Points;
1779  n = ctx->EvalMap.Map2Texture3.Uorder
1780  * ctx->EvalMap.Map2Texture3.Vorder * 3;
1781  break;
1783  data = ctx->EvalMap.Map2Texture4.Points;
1784  n = ctx->EvalMap.Map2Texture4.Uorder
1785  * ctx->EvalMap.Map2Texture4.Vorder * 4;
1786  break;
1787  case GL_MAP2_VERTEX_3:
1788  data = ctx->EvalMap.Map2Vertex3.Points;
1789  n = ctx->EvalMap.Map2Vertex3.Uorder
1790  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1791  break;
1792  case GL_MAP2_VERTEX_4:
1793  data = ctx->EvalMap.Map2Vertex4.Points;
1794  n = ctx->EvalMap.Map2Vertex4.Uorder
1795  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1796  break;
1797  default:
1798  gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1799  }
1800  if (data) {
1801  for (i=0;i<n;i++) {
1802  v[i] = ROUNDF(data[i]);
1803  }
1804  }
1805  break;
1806  case GL_ORDER:
1807  switch (target) {
1808  case GL_MAP1_COLOR_4:
1809  *v = ctx->EvalMap.Map1Color4.Order;
1810  break;
1811  case GL_MAP1_INDEX:
1812  *v = ctx->EvalMap.Map1Index.Order;
1813  break;
1814  case GL_MAP1_NORMAL:
1815  *v = ctx->EvalMap.Map1Normal.Order;
1816  break;
1818  *v = ctx->EvalMap.Map1Texture1.Order;
1819  break;
1821  *v = ctx->EvalMap.Map1Texture2.Order;
1822  break;
1824  *v = ctx->EvalMap.Map1Texture3.Order;
1825  break;
1827  *v = ctx->EvalMap.Map1Texture4.Order;
1828  break;
1829  case GL_MAP1_VERTEX_3:
1830  *v = ctx->EvalMap.Map1Vertex3.Order;
1831  break;
1832  case GL_MAP1_VERTEX_4:
1833  *v = ctx->EvalMap.Map1Vertex4.Order;
1834  break;
1835  case GL_MAP2_COLOR_4:
1836  v[0] = ctx->EvalMap.Map2Color4.Uorder;
1837  v[1] = ctx->EvalMap.Map2Color4.Vorder;
1838  break;
1839  case GL_MAP2_INDEX:
1840  v[0] = ctx->EvalMap.Map2Index.Uorder;
1841  v[1] = ctx->EvalMap.Map2Index.Vorder;
1842  break;
1843  case GL_MAP2_NORMAL:
1844  v[0] = ctx->EvalMap.Map2Normal.Uorder;
1845  v[1] = ctx->EvalMap.Map2Normal.Vorder;
1846  break;
1848  v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1849  v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1850  break;
1852  v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1853  v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1854  break;
1856  v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1857  v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1858  break;
1860  v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1861  v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1862  break;
1863  case GL_MAP2_VERTEX_3:
1864  v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1865  v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1866  break;
1867  case GL_MAP2_VERTEX_4:
1868  v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1869  v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1870  break;
1871  default:
1872  gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1873  }
1874  break;
1875  case GL_DOMAIN:
1876  switch (target) {
1877  case GL_MAP1_COLOR_4:
1878  v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
1879  v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
1880  break;
1881  case GL_MAP1_INDEX:
1882  v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
1883  v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
1884  break;
1885  case GL_MAP1_NORMAL:
1886  v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
1887  v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
1888  break;
1890  v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
1891  v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
1892  break;
1894  v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
1895  v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
1896  break;
1898  v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
1899  v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
1900  break;
1902  v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
1903  v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
1904  break;
1905  case GL_MAP1_VERTEX_3:
1906  v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
1907  v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
1908  break;
1909  case GL_MAP1_VERTEX_4:
1910  v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
1911  v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
1912  break;
1913  case GL_MAP2_COLOR_4:
1914  v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
1915  v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
1916  v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
1917  v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
1918  break;
1919  case GL_MAP2_INDEX:
1920  v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
1921  v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
1922  v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
1923  v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
1924  break;
1925  case GL_MAP2_NORMAL:
1926  v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
1927  v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
1928  v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
1929  v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
1930  break;
1932  v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
1933  v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
1934  v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
1935  v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
1936  break;
1938  v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
1939  v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
1940  v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
1941  v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
1942  break;
1944  v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
1945  v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
1946  v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
1947  v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
1948  break;
1950  v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
1951  v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
1952  v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
1953  v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
1954  break;
1955  case GL_MAP2_VERTEX_3:
1956  v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
1957  v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
1958  v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
1959  v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
1960  break;
1961  case GL_MAP2_VERTEX_4:
1962  v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
1963  v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
1964  v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
1965  v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
1966  break;
1967  default:
1968  gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1969  }
1970  break;
1971  default:
1972  gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
1973  }
1974 }
1975 
1976 
1977 
1979 {
1980  GLfloat vertex[4];
1981  GLfloat normal[3];
1982  GLfloat fcolor[4];
1983  GLubyte icolor[4];
1984  GLubyte *colorptr;
1985  GLfloat texcoord[4];
1986  GLuint index;
1987  register GLfloat uu;
1988 
1990  if (ctx->Eval.Map1Vertex4)
1991  {
1992  struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
1993  uu = (u - map->u1) / (map->u2 - map->u1);
1994  horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
1995  }
1996  else if (ctx->Eval.Map1Vertex3)
1997  {
1998  struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
1999  uu = (u - map->u1) / (map->u2 - map->u1);
2000  horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
2001  vertex[3] = 1.0;
2002  }
2003 
2005  if (ctx->Eval.Map1Index)
2006  {
2007  struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
2008  GLfloat findex;
2009  uu = (u - map->u1) / (map->u2 - map->u1);
2010  horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
2011  index = (GLuint) (GLint) findex;
2012  }
2013  else {
2014  index = ctx->Current.Index;
2015  }
2016 
2018  if (ctx->Eval.Map1Color4) {
2019  struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
2020  uu = (u - map->u1) / (map->u2 - map->u1);
2021  horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
2022  icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
2023  icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
2024  icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
2025  icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
2026  colorptr = icolor;
2027  }
2028  else {
2029  GLubyte col[4];
2030  COPY_4V(col, ctx->Current.ByteColor );
2031  colorptr = col;
2032  }
2033 
2035  if (ctx->Eval.Map1Normal) {
2036  struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
2037  uu = (u - map->u1) / (map->u2 - map->u1);
2038  horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
2039  }
2040  else {
2041  normal[0] = ctx->Current.Normal[0];
2042  normal[1] = ctx->Current.Normal[1];
2043  normal[2] = ctx->Current.Normal[2];
2044  }
2045 
2047  if (ctx->Eval.Map1TextureCoord4) {
2048  struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
2049  uu = (u - map->u1) / (map->u2 - map->u1);
2050  horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
2051  }
2052  else if (ctx->Eval.Map1TextureCoord3) {
2053  struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
2054  uu = (u - map->u1) / (map->u2 - map->u1);
2055  horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
2056  texcoord[3] = 1.0;
2057  }
2058  else if (ctx->Eval.Map1TextureCoord2) {
2059  struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
2060  uu = (u - map->u1) / (map->u2 - map->u1);
2061  horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
2062  texcoord[2] = 0.0;
2063  texcoord[3] = 1.0;
2064  }
2065  else if (ctx->Eval.Map1TextureCoord1) {
2066  struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
2067  uu = (u - map->u1) / (map->u2 - map->u1);
2068  horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
2069  texcoord[1] = 0.0;
2070  texcoord[2] = 0.0;
2071  texcoord[3] = 1.0;
2072  }
2073  else {
2074  texcoord[0] = ctx->Current.TexCoord[0];
2075  texcoord[1] = ctx->Current.TexCoord[1];
2076  texcoord[2] = ctx->Current.TexCoord[2];
2077  texcoord[3] = ctx->Current.TexCoord[3];
2078  }
2079 
2080  gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
2081 }
2082 
2083 
2085 {
2086  GLfloat vertex[4];
2087  GLfloat normal[3];
2088  GLfloat fcolor[4];
2089  GLubyte icolor[4];
2090  GLubyte *colorptr;
2091  GLfloat texcoord[4];
2092  GLuint index;
2093  register GLfloat uu, vv;
2094 
2095 #define CROSS_PROD(n, u, v) \
2096  (n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
2097  (n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
2098  (n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
2099 
2101  if(ctx->Eval.Map2Vertex4) {
2102  struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
2103  uu = (u - map->u1) / (map->u2 - map->u1);
2104  vv = (v - map->v1) / (map->v2 - map->v1);
2105 
2106  if (ctx->Eval.AutoNormal) {
2107  GLfloat du[4], dv[4];
2108 
2109  de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
2110  map->Uorder, map->Vorder);
2111 
2112  CROSS_PROD(normal, du, dv);
2114  }
2115  else {
2116  horner_bezier_surf(map->Points, vertex, uu, vv, 4,
2117  map->Uorder, map->Vorder);
2118  }
2119  }
2120  else if (ctx->Eval.Map2Vertex3) {
2121  struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
2122  uu = (u - map->u1) / (map->u2 - map->u1);
2123  vv = (v - map->v1) / (map->v2 - map->v1);
2124  if (ctx->Eval.AutoNormal) {
2125  GLfloat du[3], dv[3];
2126  de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
2127  map->Uorder, map->Vorder);
2128  CROSS_PROD(normal, du, dv);
2130  }
2131  else {
2132  horner_bezier_surf(map->Points, vertex, uu, vv, 3,
2133  map->Uorder, map->Vorder);
2134  }
2135  vertex[3] = 1.0;
2136  }
2137 #undef CROSS_PROD
2138 
2140  if (ctx->Eval.Map2Index) {
2141  GLfloat findex;
2142  struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
2143  uu = (u - map->u1) / (map->u2 - map->u1);
2144  vv = (v - map->v1) / (map->v2 - map->v1);
2145  horner_bezier_surf(map->Points, &findex, uu, vv, 1,
2146  map->Uorder, map->Vorder);
2147  index = (GLuint) (GLint) findex;
2148  }
2149  else {
2150  index = ctx->Current.Index;
2151  }
2152 
2154  if (ctx->Eval.Map2Color4) {
2155  struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
2156  uu = (u - map->u1) / (map->u2 - map->u1);
2157  vv = (v - map->v1) / (map->v2 - map->v1);
2158  horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
2159  map->Uorder, map->Vorder);
2160  icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
2161  icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
2162  icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
2163  icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
2164  colorptr = icolor;
2165  }
2166  else {
2167  GLubyte col[4];
2168  COPY_4V(col, ctx->Current.ByteColor );
2169  colorptr = col;
2170  }
2171 
2173  if (!ctx->Eval.AutoNormal
2174  || (!ctx->Eval.Map2Vertex3 && !ctx->Eval.Map2Vertex4)) {
2175  if (ctx->Eval.Map2Normal) {
2176  struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
2177  uu = (u - map->u1) / (map->u2 - map->u1);
2178  vv = (v - map->v1) / (map->v2 - map->v1);
2179  horner_bezier_surf(map->Points, normal, uu, vv, 3,
2180  map->Uorder, map->Vorder);
2181  }
2182  else {
2183  normal[0] = ctx->Current.Normal[0];
2184  normal[1] = ctx->Current.Normal[1];
2185  normal[2] = ctx->Current.Normal[2];
2186  }
2187  }
2188 
2190  if (ctx->Eval.Map2TextureCoord4) {
2191  struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
2192  uu = (u - map->u1) / (map->u2 - map->u1);
2193  vv = (v - map->v1) / (map->v2 - map->v1);
2194  horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
2195  map->Uorder, map->Vorder);
2196  }
2197  else if (ctx->Eval.Map2TextureCoord3) {
2198  struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
2199  uu = (u - map->u1) / (map->u2 - map->u1);
2200  vv = (v - map->v1) / (map->v2 - map->v1);
2201  horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
2202  map->Uorder, map->Vorder);
2203  texcoord[3] = 1.0;
2204  }
2205  else if (ctx->Eval.Map2TextureCoord2) {
2206  struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
2207  uu = (u - map->u1) / (map->u2 - map->u1);
2208  vv = (v - map->v1) / (map->v2 - map->v1);
2209  horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
2210  map->Uorder, map->Vorder);
2211  texcoord[2] = 0.0;
2212  texcoord[3] = 1.0;
2213  }
2214  else if (ctx->Eval.Map2TextureCoord1) {
2215  struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
2216  uu = (u - map->u1) / (map->u2 - map->u1);
2217  vv = (v - map->v1) / (map->v2 - map->v1);
2218  horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
2219  map->Uorder, map->Vorder);
2220  texcoord[1] = 0.0;
2221  texcoord[2] = 0.0;
2222  texcoord[3] = 1.0;
2223  }
2224  else
2225  {
2226  texcoord[0] = ctx->Current.TexCoord[0];
2227  texcoord[1] = ctx->Current.TexCoord[1];
2228  texcoord[2] = ctx->Current.TexCoord[2];
2229  texcoord[3] = ctx->Current.TexCoord[3];
2230  }
2231 
2232  gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
2233 }
2234 
2235 
2237 {
2238  if (INSIDE_BEGIN_END(ctx)) {
2239  gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid1f" );
2240  return;
2241  }
2242  if (un<1) {
2243  gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
2244  return;
2245  }
2246  ctx->Eval.MapGrid1un = un;
2247  ctx->Eval.MapGrid1u1 = u1;
2248  ctx->Eval.MapGrid1u2 = u2;
2249 }
2250 
2251 
2253  GLint vn, GLfloat v1, GLfloat v2 )
2254 {
2255  if (INSIDE_BEGIN_END(ctx)) {
2256  gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid2f" );
2257  return;
2258  }
2259  if (un<1) {
2260  gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
2261  return;
2262  }
2263  if (vn<1) {
2264  gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
2265  return;
2266  }
2267  ctx->Eval.MapGrid2un = un;
2268  ctx->Eval.MapGrid2u1 = u1;
2269  ctx->Eval.MapGrid2u2 = u2;
2270  ctx->Eval.MapGrid2vn = vn;
2271  ctx->Eval.MapGrid2v1 = v1;
2272  ctx->Eval.MapGrid2v2 = v2;
2273 }
2274 
2275 
2277 {
2278  GLfloat u, du;
2279 
2280  if (i==0) {
2281  u = ctx->Eval.MapGrid1u1;
2282  }
2283  else if (i==ctx->Eval.MapGrid1un) {
2284  u = ctx->Eval.MapGrid1u2;
2285  }
2286  else {
2287  du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
2288  / (GLfloat) ctx->Eval.MapGrid1un;
2289  u = i * du + ctx->Eval.MapGrid1u1;
2290  }
2291  gl_EvalCoord1f( ctx, u );
2292 }
2293 
2294 
2295 
2297 {
2298  GLfloat u, du;
2299  GLfloat v, dv;
2300 
2301  if (i==0) {
2302  u = ctx->Eval.MapGrid2u1;
2303  }
2304  else if (i==ctx->Eval.MapGrid2un) {
2305  u = ctx->Eval.MapGrid2u2;
2306  }
2307  else {
2308  du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
2309  / (GLfloat) ctx->Eval.MapGrid2un;
2310  u = i * du + ctx->Eval.MapGrid2u1;
2311  }
2312 
2313  if (j==0) {
2314  v = ctx->Eval.MapGrid2v1;
2315  }
2316  else if (j==ctx->Eval.MapGrid2vn) {
2317  v = ctx->Eval.MapGrid2v2;
2318  }
2319  else {
2320  dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
2321  / (GLfloat) ctx->Eval.MapGrid2vn;
2322  v = j * dv + ctx->Eval.MapGrid2v1;
2323  }
2324 
2325  gl_EvalCoord2f( ctx, u, v );
2326 }
2327 
2328 
2329 
2331 {
2332  GLint i;
2333  GLfloat u, du;
2334  GLenum prim;
2335 
2336  if (INSIDE_BEGIN_END(ctx)) {
2337  gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
2338  return;
2339  }
2340 
2341  switch (mode) {
2342  case GL_POINT:
2343  prim = GL_POINTS;
2344  break;
2345  case GL_LINE:
2346  prim = GL_LINE_STRIP;
2347  break;
2348  default:
2349  gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
2350  return;
2351  }
2352 
2353  du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
2354  / (GLfloat) ctx->Eval.MapGrid1un;
2355 
2356  gl_Begin( ctx, prim );
2357  for (i=i1;i<=i2;i++) {
2358  if (i==0) {
2359  u = ctx->Eval.MapGrid1u1;
2360  }
2361  else if (i==ctx->Eval.MapGrid1un) {
2362  u = ctx->Eval.MapGrid1u2;
2363  }
2364  else {
2365  u = i * du + ctx->Eval.MapGrid1u1;
2366  }
2367  gl_EvalCoord1f( ctx, u );
2368  }
2369  gl_End(ctx);
2370 }
2371 
2372 
2373 
2374 void gl_EvalMesh2( GLcontext* ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
2375 {
2376  GLint i, j;
2377  GLfloat u, du, v, dv, v1, v2;
2378 
2379  if (INSIDE_BEGIN_END(ctx)) {
2380  gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
2381  return;
2382  }
2383 
2384  du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
2385  / (GLfloat) ctx->Eval.MapGrid2un;
2386  dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
2387  / (GLfloat) ctx->Eval.MapGrid2vn;
2388 
2389 #define I_TO_U( I, U ) \
2390  if ((I)==0) { \
2391  U = ctx->Eval.MapGrid2u1; \
2392  } \
2393  else if ((I)==ctx->Eval.MapGrid2un) { \
2394  U = ctx->Eval.MapGrid2u2; \
2395  } \
2396  else { \
2397  U = (I) * du + ctx->Eval.MapGrid2u1;\
2398  }
2399 
2400 #define J_TO_V( J, V ) \
2401  if ((J)==0) { \
2402  V = ctx->Eval.MapGrid2v1; \
2403  } \
2404  else if ((J)==ctx->Eval.MapGrid2vn) { \
2405  V = ctx->Eval.MapGrid2v2; \
2406  } \
2407  else { \
2408  V = (J) * dv + ctx->Eval.MapGrid2v1;\
2409  }
2410 
2411  switch (mode) {
2412  case GL_POINT:
2413  gl_Begin( ctx, GL_POINTS );
2414  for (j=j1;j<=j2;j++) {
2415  J_TO_V( j, v );
2416  for (i=i1;i<=i2;i++) {
2417  I_TO_U( i, u );
2418  gl_EvalCoord2f( ctx, u, v );
2419  }
2420  }
2421  gl_End(ctx);
2422  break;
2423  case GL_LINE:
2424  for (j=j1;j<=j2;j++) {
2425  J_TO_V( j, v );
2426  gl_Begin( ctx, GL_LINE_STRIP );
2427  for (i=i1;i<=i2;i++) {
2428  I_TO_U( i, u );
2429  gl_EvalCoord2f( ctx, u, v );
2430  }
2431  gl_End(ctx);
2432  }
2433  for (i=i1;i<=i2;i++) {
2434  I_TO_U( i, u );
2435  gl_Begin( ctx, GL_LINE_STRIP );
2436  for (j=j1;j<=j2;j++) {
2437  J_TO_V( j, v );
2438  gl_EvalCoord2f( ctx, u, v );
2439  }
2440  gl_End(ctx);
2441  }
2442  break;
2443  case GL_FILL:
2444  for (j=j1;j<j2;j++) {
2445  /* NOTE: a quad strip can't be used because the four */
2446  /* can't be guaranteed to be coplanar! */
2447  gl_Begin( ctx, GL_TRIANGLE_STRIP );
2448  J_TO_V( j, v1 );
2449  J_TO_V( j+1, v2 );
2450  for (i=i1;i<=i2;i++) {
2451  I_TO_U( i, u );
2452  gl_EvalCoord2f( ctx, u, v1 );
2453  gl_EvalCoord2f( ctx, u, v2 );
2454  }
2455  gl_End(ctx);
2456  }
2457  break;
2458  default:
2459  gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
2460  return;
2461  }
2462 
2463 #undef I_TO_U
2464 #undef J_TO_V
2465 }
2466 
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
double GLdouble
Definition: gl.h:163
#define GL_MAP1_VERTEX_4
Definition: gl.h:559
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint vstride
Definition: glext.h:8308
GLfloat * gl_copy_map_points1f(GLenum target, GLint ustride, GLint uorder, const GLfloat *points)
Definition: eval.c:587
GLdouble GLdouble GLint ustride
Definition: glext.h:8308
GLdouble GLdouble u2
Definition: glext.h:8308
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
Definition: mesh.c:4557
void gl_EvalMesh2(GLcontext *ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
Definition: eval.c:2374
#define GL_MAP1_COLOR_4
Definition: gl.h:551
#define GL_POINTS
Definition: gl.h:190
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint un
Definition: glfuncs.h:236
void gl_GetMapdv(GLcontext *ctx, GLenum target, GLenum query, GLdouble *v)
Definition: eval.c:1170
void gl_EvalMesh1(GLcontext *ctx, GLenum mode, GLint i1, GLint i2)
Definition: eval.c:2330
unsigned char GLubyte
Definition: gl.h:157
static const BYTE us[]
Definition: encode.c:689
#define GL_FALSE
Definition: gl.h:173
#define free
Definition: debug_ros.c:5
#define GL_MAP1_INDEX
Definition: gl.h:552
#define GL_MAP2_TEXTURE_COORD_1
Definition: gl.h:563
GLdouble n
Definition: glext.h:7729
void gl_MapGrid1f(GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2)
Definition: eval.c:2236
GLdouble GLdouble t
Definition: gl.h:2047
#define CROSS_PROD(n, u, v)
static BYTE cn[]
Definition: cert.c:2938
void gl_eval_vertex(GLcontext *ctx, const GLfloat vertex[4], const GLfloat normal[3], const GLubyte color[4], GLuint index, const GLfloat texcoord[4])
Definition: vbfill.c:1290
GLuint buffer
Definition: glext.h:5915
#define GL_MAP2_TEXTURE_COORD_4
Definition: gl.h:566
struct gl_current_attrib Current
Definition: types.h:1320
GLvisual * Visual
Definition: types.h:1272
void gl_GetMapfv(GLcontext *ctx, GLenum target, GLenum query, GLfloat *v)
Definition: eval.c:1439
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint vorder
Definition: glext.h:8308
static void horner_bezier_curve(GLfloat *cp, GLfloat *out, GLfloat t, GLuint dim, GLuint order)
Definition: eval.c:131
GLdouble u1
Definition: glext.h:8308
static void horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v, GLuint dim, GLuint uorder, GLuint vorder)
Definition: eval.c:176
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
#define GL_MAP1_TEXTURE_COORD_2
Definition: gl.h:555
#define ROUNDF(X)
Definition: macros.h:147
#define J_TO_V(J, V)
static void de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv, GLfloat u, GLfloat v, GLuint dim, GLuint uorder, GLuint vorder)
Definition: eval.c:258
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define I_TO_U(I, U)
GLfloat * Points
Definition: types.h:1040
void gl_EvalCoord1f(GLcontext *ctx, GLfloat u)
Definition: eval.c:1978
unsigned char GLboolean
Definition: gl.h:151
#define GL_LINE
Definition: gl.h:266
#define GL_MAP2_INDEX
Definition: gl.h:561
smooth NULL
Definition: ftsmooth.c:416
GLfloat AlphaScale
Definition: types.h:1143
#define GL_MAP2_TEXTURE_COORD_3
Definition: gl.h:565
#define GL_MAP2_VERTEX_4
Definition: gl.h:568
GLfloat BlueScale
Definition: types.h:1142
GLuint index
Definition: glext.h:6031
#define GL_LINE_STRIP
Definition: gl.h:193
GLfloat GreenScale
Definition: types.h:1141
#define MAX_EVAL_ORDER
Definition: config.h:105
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
GLboolean Retain
Definition: types.h:1041
void gl_init_eval(void)
Definition: eval.c:89
GLdouble GLdouble GLint GLint uorder
Definition: glext.h:8308
struct gl_eval_attrib Eval
Definition: types.h:1322
GLsizei stride
Definition: glext.h:5848
GLsizeiptr size
Definition: glext.h:5919
void gl_EvalCoord2f(GLcontext *ctx, GLfloat u, GLfloat v)
Definition: eval.c:2084
GLfloat * gl_copy_map_points2d(GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder, const GLdouble *points)
Definition: eval.c:689
#define GL_MAP1_TEXTURE_COORD_3
Definition: gl.h:556
#define GL_MAP1_TEXTURE_COORD_1
Definition: gl.h:554
#define GL_MAP1_NORMAL
Definition: gl.h:553
#define GL_MAP2_NORMAL
Definition: gl.h:562
#define GL_POINT
Definition: gl.h:265
static GLint components(GLenum target)
Definition: eval.c:549
#define GL_MAP1_TEXTURE_COORD_4
Definition: gl.h:557
static FILE * out
Definition: regtests2xml.c:44
#define GL_MAP2_COLOR_4
Definition: gl.h:560
void gl_EvalPoint1(GLcontext *ctx, GLint i)
Definition: eval.c:2276
Definition: _map.h:44
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define GL_INVALID_VALUE
Definition: gl.h:695
#define NORMALIZE_3FV(V)
Definition: mmath.h:68
GLsizei const GLfloat * points
Definition: glext.h:8112
#define GL_INVALID_OPERATION
Definition: gl.h:696
struct gl_evaluators EvalMap
Definition: types.h:1346
#define CN(I, J, K)
#define GL_MAP2_VERTEX_3
Definition: gl.h:567
#define index(s, c)
Definition: various.h:29
void gl_Map1f(GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points, GLboolean retain)
Definition: eval.c:836
GLboolean Retain
Definition: types.h:1054
GLdouble s
Definition: gl.h:2039
#define GL_ORDER
Definition: gl.h:574
unsigned int GLenum
Definition: gl.h:150
GLenum mode
Definition: glext.h:6217
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
void gl_GetMapiv(GLcontext *ctx, GLenum target, GLenum query, GLint *v)
Definition: eval.c:1708
#define GL_FILL
Definition: gl.h:267
GLfloat * gl_copy_map_points1d(GLenum target, GLint ustride, GLint uorder, const GLdouble *points)
Definition: eval.c:613
const GLdouble * v
Definition: gl.h:2040
unsigned int GLuint
Definition: gl.h:159
void gl_End(GLcontext *ctx)
Definition: vbfill.c:1424
void gl_free_control_points(GLcontext *ctx, GLenum target, GLfloat *data)
Definition: eval.c:732
GLfloat RedScale
Definition: types.h:1140
#define GL_DOMAIN
Definition: gl.h:575
#define GL_INVALID_ENUM
Definition: gl.h:694
GLfloat * gl_copy_map_points2f(GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder, const GLfloat *points)
Definition: eval.c:646
#define GL_MAP1_VERTEX_3
Definition: gl.h:558
LOCAL int prim(arg_t *ap)
Definition: match.c:440
#define GL_OUT_OF_MEMORY
Definition: gl.h:699
float GLfloat
Definition: gl.h:161
POINT cp
Definition: magnifier.c:59
void gl_EvalPoint2(GLcontext *ctx, GLint i, GLint j)
Definition: eval.c:2296
GLenum target
Definition: glext.h:7315
void gl_Map2f(GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points, GLboolean retain)
Definition: eval.c:988
void gl_Begin(GLcontext *ctx, GLenum p)
Definition: vbfill.c:1341
int GLint
Definition: gl.h:156
#define malloc
Definition: debug_ros.c:4
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint vn
Definition: glfuncs.h:238
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
GLfloat GLfloat p
Definition: glext.h:8902
void gl_MapGrid2f(GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
Definition: eval.c:2252
GLfloat * Points
Definition: types.h:1053
#define GL_MAP2_TEXTURE_COORD_2
Definition: gl.h:564
#define GL_COEFF
Definition: gl.h:573
GLfloat GLfloat v1
Definition: glext.h:6062
int k
Definition: mpi.c:3369
#define DCN(I, J)
#define COPY_4V(DST, SRC)
Definition: macros.h:102