← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/extras/Mesa/src/eval.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/extras/Mesa/src/eval.c
 
1
 
 
2
/*
 
3
 * Mesa 3-D graphics library
 
4
 * Version:  3.5
 
5
 *
 
6
 * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
 
7
 *
 
8
 * Permission is hereby granted, free of charge, to any person obtaining a
 
9
 * copy of this software and associated documentation files (the "Software"),
 
10
 * to deal in the Software without restriction, including without limitation
 
11
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 
12
 * and/or sell copies of the Software, and to permit persons to whom the
 
13
 * Software is furnished to do so, subject to the following conditions:
 
14
 *
 
15
 * The above copyright notice and this permission notice shall be included
 
16
 * in all copies or substantial portions of the Software.
 
17
 *
 
18
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
19
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
20
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 
21
 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 
22
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
23
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
24
 */
 
25
 
 
26
 
 
27
/*
 
28
 * eval.c was written by
 
29
 * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
 
30
 * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
 
31
 *
 
32
 * My original implementation of evaluators was simplistic and didn't
 
33
 * compute surface normal vectors properly.  Bernd and Volker applied
 
34
 * used more sophisticated methods to get better results.
 
35
 *
 
36
 * Thanks guys!
 
37
 */
 
38
 
 
39
 
 
40
#ifdef PC_HEADER
 
41
#include "all.h"
 
42
#else
 
43
#include "glheader.h"
 
44
#include "colormac.h"
 
45
#include "context.h"
 
46
#include "eval.h"
 
47
#include "macros.h"
 
48
#include "mem.h"
 
49
#include "mmath.h"
 
50
#include "mtypes.h"
 
51
#endif
 
52
 
 
53
 
 
54
/*
 
55
 * Return the number of components per control point for any type of
 
56
 * evaluator.  Return 0 if bad target.
 
57
 * See table 5.1 in the OpenGL 1.2 spec.
 
58
 */
 
59
GLuint _mesa_evaluator_components( GLenum target )
 
60
{
 
61
   switch (target) {
 
62
      case GL_MAP1_VERTEX_3:            return 3;
 
63
      case GL_MAP1_VERTEX_4:            return 4;
 
64
      case GL_MAP1_INDEX:               return 1;
 
65
      case GL_MAP1_COLOR_4:             return 4;
 
66
      case GL_MAP1_NORMAL:              return 3;
 
67
      case GL_MAP1_TEXTURE_COORD_1:     return 1;
 
68
      case GL_MAP1_TEXTURE_COORD_2:     return 2;
 
69
      case GL_MAP1_TEXTURE_COORD_3:     return 3;
 
70
      case GL_MAP1_TEXTURE_COORD_4:     return 4;
 
71
      case GL_MAP2_VERTEX_3:            return 3;
 
72
      case GL_MAP2_VERTEX_4:            return 4;
 
73
      case GL_MAP2_INDEX:               return 1;
 
74
      case GL_MAP2_COLOR_4:             return 4;
 
75
      case GL_MAP2_NORMAL:              return 3;
 
76
      case GL_MAP2_TEXTURE_COORD_1:     return 1;
 
77
      case GL_MAP2_TEXTURE_COORD_2:     return 2;
 
78
      case GL_MAP2_TEXTURE_COORD_3:     return 3;
 
79
      case GL_MAP2_TEXTURE_COORD_4:     return 4;
 
80
      default:                          return 0;
 
81
   }
 
82
}
 
83
 
 
84
 
 
85
/**********************************************************************/
 
86
/***            Copy and deallocate control points                  ***/
 
87
/**********************************************************************/
 
88
 
 
89
 
 
90
/*
 
91
 * Copy 1-parametric evaluator control points from user-specified
 
92
 * memory space to a buffer of contiguous control points.
 
93
 * Input:  see glMap1f for details
 
94
 * Return:  pointer to buffer of contiguous control points or NULL if out
 
95
 *          of memory.
 
96
 */
 
97
GLfloat *_mesa_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
 
98
                               const GLfloat *points )
 
99
{
 
100
   GLfloat *buffer, *p;
 
101
   GLint i, k, size = _mesa_evaluator_components(target);
 
102
 
 
103
   if (!points || size==0) {
 
104
      return NULL;
 
105
   }
 
106
 
 
107
   buffer = (GLfloat *) MALLOC(uorder * size * sizeof(GLfloat));
 
108
 
 
109
   if(buffer)
 
110
      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
 
111
        for(k=0; k<size; k++)
 
112
          *p++ = points[k];
 
113
 
 
114
   return buffer;
 
115
}
 
116
 
 
117
 
 
118
 
 
119
/*
 
120
 * Same as above but convert doubles to floats.
 
121
 */
 
122
GLfloat *_mesa_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
 
123
                               const GLdouble *points )
 
124
{
 
125
   GLfloat *buffer, *p;
 
126
   GLint i, k, size = _mesa_evaluator_components(target);
 
127
 
 
128
   if (!points || size==0) {
 
129
      return NULL;
 
130
   }
 
131
 
 
132
   buffer = (GLfloat *) MALLOC(uorder * size * sizeof(GLfloat));
 
133
 
 
134
   if(buffer)
 
135
      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
 
136
        for(k=0; k<size; k++)
 
137
          *p++ = (GLfloat) points[k];
 
138
 
 
139
   return buffer;
 
140
}
 
141
 
 
142
 
 
143
 
 
144
/*
 
145
 * Copy 2-parametric evaluator control points from user-specified
 
146
 * memory space to a buffer of contiguous control points.
 
147
 * Additional memory is allocated to be used by the horner and
 
148
 * de Casteljau evaluation schemes.
 
149
 *
 
150
 * Input:  see glMap2f for details
 
151
 * Return:  pointer to buffer of contiguous control points or NULL if out
 
152
 *          of memory.
 
153
 */
 
154
GLfloat *_mesa_copy_map_points2f( GLenum target,
 
155
                               GLint ustride, GLint uorder,
 
156
                               GLint vstride, GLint vorder,
 
157
                               const GLfloat *points )
 
158
{
 
159
   GLfloat *buffer, *p;
 
160
   GLint i, j, k, size, dsize, hsize;
 
161
   GLint uinc;
 
162
 
 
163
   size = _mesa_evaluator_components(target);
 
164
 
 
165
   if (!points || size==0) {
 
166
      return NULL;
 
167
   }
 
168
 
 
169
   /* max(uorder, vorder) additional points are used in      */
 
170
   /* horner evaluation and uorder*vorder additional */
 
171
   /* values are needed for de Casteljau                     */
 
172
   dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
 
173
   hsize = (uorder > vorder ? uorder : vorder)*size;
 
174
 
 
175
   if(hsize>dsize)
 
176
     buffer = (GLfloat *) MALLOC((uorder*vorder*size+hsize)*sizeof(GLfloat));
 
177
   else
 
178
     buffer = (GLfloat *) MALLOC((uorder*vorder*size+dsize)*sizeof(GLfloat));
 
179
 
 
180
   /* compute the increment value for the u-loop */
 
181
   uinc = ustride - vorder*vstride;
 
182
 
 
183
   if (buffer)
 
184
      for (i=0, p=buffer; i<uorder; i++, points += uinc)
 
185
         for (j=0; j<vorder; j++, points += vstride)
 
186
            for (k=0; k<size; k++)
 
187
               *p++ = points[k];
 
188
 
 
189
   return buffer;
 
190
}
 
191
 
 
192
 
 
193
 
 
194
/*
 
195
 * Same as above but convert doubles to floats.
 
196
 */
 
197
GLfloat *_mesa_copy_map_points2d(GLenum target,
 
198
                              GLint ustride, GLint uorder,
 
199
                              GLint vstride, GLint vorder,
 
200
                              const GLdouble *points )
 
201
{
 
202
   GLfloat *buffer, *p;
 
203
   GLint i, j, k, size, hsize, dsize;
 
204
   GLint uinc;
 
205
 
 
206
   size = _mesa_evaluator_components(target);
 
207
 
 
208
   if (!points || size==0) {
 
209
      return NULL;
 
210
   }
 
211
 
 
212
   /* max(uorder, vorder) additional points are used in      */
 
213
   /* horner evaluation and uorder*vorder additional */
 
214
   /* values are needed for de Casteljau                     */
 
215
   dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
 
216
   hsize = (uorder > vorder ? uorder : vorder)*size;
 
217
 
 
218
   if(hsize>dsize)
 
219
     buffer = (GLfloat *) MALLOC((uorder*vorder*size+hsize)*sizeof(GLfloat));
 
220
   else
 
221
     buffer = (GLfloat *) MALLOC((uorder*vorder*size+dsize)*sizeof(GLfloat));
 
222
 
 
223
   /* compute the increment value for the u-loop */
 
224
   uinc = ustride - vorder*vstride;
 
225
 
 
226
   if (buffer)
 
227
      for (i=0, p=buffer; i<uorder; i++, points += uinc)
 
228
         for (j=0; j<vorder; j++, points += vstride)
 
229
            for (k=0; k<size; k++)
 
230
               *p++ = (GLfloat) points[k];
 
231
 
 
232
   return buffer;
 
233
}
 
234
 
 
235
 
 
236
 
 
237
 
 
238
/**********************************************************************/
 
239
/***                      API entry points                          ***/
 
240
/**********************************************************************/
 
241
 
 
242
 
 
243
/*
 
244
 * This does the work of glMap1[fd].
 
245
 */
 
246
static void
 
247
map1(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
 
248
     GLint uorder, const GLvoid *points, GLenum type )
 
249
{
 
250
   GET_CURRENT_CONTEXT(ctx);
 
251
   GLint k;
 
252
   GLfloat *pnts;
 
253
   struct gl_1d_map *map = 0;
 
254
   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
255
 
 
256
   assert(type == GL_FLOAT || type == GL_DOUBLE);
 
257
 
 
258
   if (u1 == u2) {
 
259
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
 
260
      return;
 
261
   }
 
262
   if (uorder < 1 || uorder > MAX_EVAL_ORDER) {
 
263
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
 
264
      return;
 
265
   }
 
266
   if (!points) {
 
267
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(points)" );
 
268
      return;
 
269
   }
 
270
 
 
271
   k = _mesa_evaluator_components( target );
 
272
   if (k == 0) {
 
273
      _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
 
274
   }
 
275
 
 
276
   if (ustride < k) {
 
277
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
 
278
      return;
 
279
   }
 
280
 
 
281
   if (ctx->Texture.CurrentUnit != 0) {
 
282
      /* See OpenGL 1.2.1 spec, section F.2.13 */
 
283
      _mesa_error( ctx, GL_INVALID_OPERATION, "glMap2(ACTIVE_TEXTURE != 0)" );
 
284
      return;
 
285
   }
 
286
 
 
287
   switch (target) {
 
288
      case GL_MAP1_VERTEX_3:
 
289
         map = &ctx->EvalMap.Map1Vertex3;
 
290
         break;
 
291
      case GL_MAP1_VERTEX_4:
 
292
         map = &ctx->EvalMap.Map1Vertex4;
 
293
         break;
 
294
      case GL_MAP1_INDEX:
 
295
         map = &ctx->EvalMap.Map1Index;
 
296
         break;
 
297
      case GL_MAP1_COLOR_4:
 
298
         map = &ctx->EvalMap.Map1Color4;
 
299
         break;
 
300
      case GL_MAP1_NORMAL:
 
301
         map = &ctx->EvalMap.Map1Normal;
 
302
         break;
 
303
      case GL_MAP1_TEXTURE_COORD_1:
 
304
         map = &ctx->EvalMap.Map1Texture1;
 
305
         break;
 
306
      case GL_MAP1_TEXTURE_COORD_2:
 
307
         map = &ctx->EvalMap.Map1Texture2;
 
308
         break;
 
309
      case GL_MAP1_TEXTURE_COORD_3:
 
310
         map = &ctx->EvalMap.Map1Texture3;
 
311
         break;
 
312
      case GL_MAP1_TEXTURE_COORD_4:
 
313
         map = &ctx->EvalMap.Map1Texture4;
 
314
         break;
 
315
      default:
 
316
         _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
 
317
         return;
 
318
   }
 
319
 
 
320
   /* make copy of the control points */
 
321
   if (type == GL_FLOAT)
 
322
      pnts = _mesa_copy_map_points1f(target, ustride, uorder, (GLfloat*) points);
 
323
   else
 
324
      pnts = _mesa_copy_map_points1d(target, ustride, uorder, (GLdouble*) points);
 
325
 
 
326
 
 
327
   FLUSH_VERTICES(ctx, _NEW_EVAL);
 
328
   map->Order = uorder;
 
329
   map->u1 = u1;
 
330
   map->u2 = u2;
 
331
   map->du = 1.0F / (u2 - u1);
 
332
   if (map->Points)
 
333
      FREE( map->Points );
 
334
   map->Points = pnts;
 
335
}
 
336
 
 
337
 
 
338
 
 
339
void
 
340
_mesa_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
 
341
             GLint order, const GLfloat *points )
 
342
{
 
343
   map1(target, u1, u2, stride, order, points, GL_FLOAT);
 
344
}
 
345
 
 
346
 
 
347
void
 
348
_mesa_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
 
349
             GLint order, const GLdouble *points )
 
350
{
 
351
   map1(target, (GLfloat) u1, (GLfloat) u2, stride, order, points, GL_DOUBLE);
 
352
}
 
353
 
 
354
 
 
355
static void
 
356
map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
 
357
      GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
 
358
      const GLvoid *points, GLenum type )
 
359
{
 
360
   GET_CURRENT_CONTEXT(ctx);
 
361
   GLint k;
 
362
   GLfloat *pnts;
 
363
   struct gl_2d_map *map = 0;
 
364
   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
365
 
 
366
   if (u1==u2) {
 
367
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
 
368
      return;
 
369
   }
 
370
 
 
371
   if (v1==v2) {
 
372
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
 
373
      return;
 
374
   }
 
375
 
 
376
   if (uorder<1 || uorder>MAX_EVAL_ORDER) {
 
377
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
 
378
      return;
 
379
   }
 
380
 
 
381
   if (vorder<1 || vorder>MAX_EVAL_ORDER) {
 
382
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
 
383
      return;
 
384
   }
 
385
 
 
386
   k = _mesa_evaluator_components( target );
 
387
   if (k==0) {
 
388
      _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
 
389
   }
 
390
 
 
391
   if (ustride < k) {
 
392
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
 
393
      return;
 
394
   }
 
395
   if (vstride < k) {
 
396
      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
 
397
      return;
 
398
   }
 
399
 
 
400
   if (ctx->Texture.CurrentUnit != 0) {
 
401
      /* See OpenGL 1.2.1 spec, section F.2.13 */
 
402
      _mesa_error( ctx, GL_INVALID_OPERATION, "glMap2(ACTIVE_TEXTURE != 0)" );
 
403
      return;
 
404
   }
 
405
 
 
406
   switch (target) {
 
407
      case GL_MAP2_VERTEX_3:
 
408
         map = &ctx->EvalMap.Map2Vertex3;
 
409
         break;
 
410
      case GL_MAP2_VERTEX_4:
 
411
         map = &ctx->EvalMap.Map2Vertex4;
 
412
         break;
 
413
      case GL_MAP2_INDEX:
 
414
         map = &ctx->EvalMap.Map2Index;
 
415
         break;
 
416
      case GL_MAP2_COLOR_4:
 
417
         map = &ctx->EvalMap.Map2Color4;
 
418
         break;
 
419
      case GL_MAP2_NORMAL:
 
420
         map = &ctx->EvalMap.Map2Normal;
 
421
         break;
 
422
      case GL_MAP2_TEXTURE_COORD_1:
 
423
         map = &ctx->EvalMap.Map2Texture1;
 
424
         break;
 
425
      case GL_MAP2_TEXTURE_COORD_2:
 
426
         map = &ctx->EvalMap.Map2Texture2;
 
427
         break;
 
428
      case GL_MAP2_TEXTURE_COORD_3:
 
429
         map = &ctx->EvalMap.Map2Texture3;
 
430
         break;
 
431
      case GL_MAP2_TEXTURE_COORD_4:
 
432
         map = &ctx->EvalMap.Map2Texture4;
 
433
         break;
 
434
      default:
 
435
         _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
 
436
         return;
 
437
   }
 
438
 
 
439
   /* make copy of the control points */
 
440
   if (type == GL_FLOAT)
 
441
      pnts = _mesa_copy_map_points2f(target, ustride, uorder,
 
442
                                  vstride, vorder, (GLfloat*) points);
 
443
   else
 
444
      pnts = _mesa_copy_map_points2d(target, ustride, uorder,
 
445
                                  vstride, vorder, (GLdouble*) points);
 
446
 
 
447
 
 
448
   FLUSH_VERTICES(ctx, _NEW_EVAL);
 
449
   map->Uorder = uorder;
 
450
   map->u1 = u1;
 
451
   map->u2 = u2;
 
452
   map->du = 1.0F / (u2 - u1);
 
453
   map->Vorder = vorder;
 
454
   map->v1 = v1;
 
455
   map->v2 = v2;
 
456
   map->dv = 1.0F / (v2 - v1);
 
457
   if (map->Points)
 
458
      FREE( map->Points );
 
459
   map->Points = pnts;
 
460
}
 
461
 
 
462
 
 
463
void
 
464
_mesa_Map2f( GLenum target,
 
465
             GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
 
466
             GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
 
467
             const GLfloat *points)
 
468
{
 
469
   map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
 
470
        points, GL_FLOAT);
 
471
}
 
472
 
 
473
 
 
474
void
 
475
_mesa_Map2d( GLenum target,
 
476
             GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
 
477
             GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
 
478
             const GLdouble *points )
 
479
{
 
480
   map2(target, (GLfloat) u1, (GLfloat) u2, ustride, uorder, 
 
481
        (GLfloat) v1, (GLfloat) v2, vstride, vorder, points, GL_DOUBLE);
 
482
}
 
483
 
 
484
 
 
485
 
 
486
void
 
487
_mesa_GetMapdv( GLenum target, GLenum query, GLdouble *v )
 
488
{
 
489
   GET_CURRENT_CONTEXT(ctx);
 
490
   GLint i, n;
 
491
   GLfloat *data;
 
492
   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
493
 
 
494
   switch (query) {
 
495
      case GL_COEFF:
 
496
         switch (target) {
 
497
            case GL_MAP1_COLOR_4:
 
498
               data = ctx->EvalMap.Map1Color4.Points;
 
499
               n = ctx->EvalMap.Map1Color4.Order * 4;
 
500
               break;
 
501
            case GL_MAP1_INDEX:
 
502
               data = ctx->EvalMap.Map1Index.Points;
 
503
               n = ctx->EvalMap.Map1Index.Order;
 
504
               break;
 
505
            case GL_MAP1_NORMAL:
 
506
               data = ctx->EvalMap.Map1Normal.Points;
 
507
               n = ctx->EvalMap.Map1Normal.Order * 3;
 
508
               break;
 
509
            case GL_MAP1_TEXTURE_COORD_1:
 
510
               data = ctx->EvalMap.Map1Texture1.Points;
 
511
               n = ctx->EvalMap.Map1Texture1.Order * 1;
 
512
               break;
 
513
            case GL_MAP1_TEXTURE_COORD_2:
 
514
               data = ctx->EvalMap.Map1Texture2.Points;
 
515
               n = ctx->EvalMap.Map1Texture2.Order * 2;
 
516
               break;
 
517
            case GL_MAP1_TEXTURE_COORD_3:
 
518
               data = ctx->EvalMap.Map1Texture3.Points;
 
519
               n = ctx->EvalMap.Map1Texture3.Order * 3;
 
520
               break;
 
521
            case GL_MAP1_TEXTURE_COORD_4:
 
522
               data = ctx->EvalMap.Map1Texture4.Points;
 
523
               n = ctx->EvalMap.Map1Texture4.Order * 4;
 
524
               break;
 
525
            case GL_MAP1_VERTEX_3:
 
526
               data = ctx->EvalMap.Map1Vertex3.Points;
 
527
               n = ctx->EvalMap.Map1Vertex3.Order * 3;
 
528
               break;
 
529
            case GL_MAP1_VERTEX_4:
 
530
               data = ctx->EvalMap.Map1Vertex4.Points;
 
531
               n = ctx->EvalMap.Map1Vertex4.Order * 4;
 
532
               break;
 
533
            case GL_MAP2_COLOR_4:
 
534
               data = ctx->EvalMap.Map2Color4.Points;
 
535
               n = ctx->EvalMap.Map2Color4.Uorder
 
536
                 * ctx->EvalMap.Map2Color4.Vorder * 4;
 
537
               break;
 
538
            case GL_MAP2_INDEX:
 
539
               data = ctx->EvalMap.Map2Index.Points;
 
540
               n = ctx->EvalMap.Map2Index.Uorder
 
541
                 * ctx->EvalMap.Map2Index.Vorder;
 
542
               break;
 
543
            case GL_MAP2_NORMAL:
 
544
               data = ctx->EvalMap.Map2Normal.Points;
 
545
               n = ctx->EvalMap.Map2Normal.Uorder
 
546
                 * ctx->EvalMap.Map2Normal.Vorder * 3;
 
547
               break;
 
548
            case GL_MAP2_TEXTURE_COORD_1:
 
549
               data = ctx->EvalMap.Map2Texture1.Points;
 
550
               n = ctx->EvalMap.Map2Texture1.Uorder
 
551
                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
 
552
               break;
 
553
            case GL_MAP2_TEXTURE_COORD_2:
 
554
               data = ctx->EvalMap.Map2Texture2.Points;
 
555
               n = ctx->EvalMap.Map2Texture2.Uorder
 
556
                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
 
557
               break;
 
558
            case GL_MAP2_TEXTURE_COORD_3:
 
559
               data = ctx->EvalMap.Map2Texture3.Points;
 
560
               n = ctx->EvalMap.Map2Texture3.Uorder
 
561
                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
 
562
               break;
 
563
            case GL_MAP2_TEXTURE_COORD_4:
 
564
               data = ctx->EvalMap.Map2Texture4.Points;
 
565
               n = ctx->EvalMap.Map2Texture4.Uorder
 
566
                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
 
567
               break;
 
568
            case GL_MAP2_VERTEX_3:
 
569
               data = ctx->EvalMap.Map2Vertex3.Points;
 
570
               n = ctx->EvalMap.Map2Vertex3.Uorder
 
571
                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
 
572
               break;
 
573
            case GL_MAP2_VERTEX_4:
 
574
               data = ctx->EvalMap.Map2Vertex4.Points;
 
575
               n = ctx->EvalMap.Map2Vertex4.Uorder
 
576
                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
 
577
               break;
 
578
            default:
 
579
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
 
580
               return;
 
581
         }
 
582
         if (data) {
 
583
            for (i=0;i<n;i++) {
 
584
               v[i] = data[i];
 
585
            }
 
586
         }
 
587
         break;
 
588
      case GL_ORDER:
 
589
         switch (target) {
 
590
            case GL_MAP1_COLOR_4:
 
591
               *v = ctx->EvalMap.Map1Color4.Order;
 
592
               break;
 
593
            case GL_MAP1_INDEX:
 
594
               *v = ctx->EvalMap.Map1Index.Order;
 
595
               break;
 
596
            case GL_MAP1_NORMAL:
 
597
               *v = ctx->EvalMap.Map1Normal.Order;
 
598
               break;
 
599
            case GL_MAP1_TEXTURE_COORD_1:
 
600
               *v = ctx->EvalMap.Map1Texture1.Order;
 
601
               break;
 
602
            case GL_MAP1_TEXTURE_COORD_2:
 
603
               *v = ctx->EvalMap.Map1Texture2.Order;
 
604
               break;
 
605
            case GL_MAP1_TEXTURE_COORD_3:
 
606
               *v = ctx->EvalMap.Map1Texture3.Order;
 
607
               break;
 
608
            case GL_MAP1_TEXTURE_COORD_4:
 
609
               *v = ctx->EvalMap.Map1Texture4.Order;
 
610
               break;
 
611
            case GL_MAP1_VERTEX_3:
 
612
               *v = ctx->EvalMap.Map1Vertex3.Order;
 
613
               break;
 
614
            case GL_MAP1_VERTEX_4:
 
615
               *v = ctx->EvalMap.Map1Vertex4.Order;
 
616
               break;
 
617
            case GL_MAP2_COLOR_4:
 
618
               v[0] = ctx->EvalMap.Map2Color4.Uorder;
 
619
               v[1] = ctx->EvalMap.Map2Color4.Vorder;
 
620
               break;
 
621
            case GL_MAP2_INDEX:
 
622
               v[0] = ctx->EvalMap.Map2Index.Uorder;
 
623
               v[1] = ctx->EvalMap.Map2Index.Vorder;
 
624
               break;
 
625
            case GL_MAP2_NORMAL:
 
626
               v[0] = ctx->EvalMap.Map2Normal.Uorder;
 
627
               v[1] = ctx->EvalMap.Map2Normal.Vorder;
 
628
               break;
 
629
            case GL_MAP2_TEXTURE_COORD_1:
 
630
               v[0] = ctx->EvalMap.Map2Texture1.Uorder;
 
631
               v[1] = ctx->EvalMap.Map2Texture1.Vorder;
 
632
               break;
 
633
            case GL_MAP2_TEXTURE_COORD_2:
 
634
               v[0] = ctx->EvalMap.Map2Texture2.Uorder;
 
635
               v[1] = ctx->EvalMap.Map2Texture2.Vorder;
 
636
               break;
 
637
            case GL_MAP2_TEXTURE_COORD_3:
 
638
               v[0] = ctx->EvalMap.Map2Texture3.Uorder;
 
639
               v[1] = ctx->EvalMap.Map2Texture3.Vorder;
 
640
               break;
 
641
            case GL_MAP2_TEXTURE_COORD_4:
 
642
               v[0] = ctx->EvalMap.Map2Texture4.Uorder;
 
643
               v[1] = ctx->EvalMap.Map2Texture4.Vorder;
 
644
               break;
 
645
            case GL_MAP2_VERTEX_3:
 
646
               v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
 
647
               v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
 
648
               break;
 
649
            case GL_MAP2_VERTEX_4:
 
650
               v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
 
651
               v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
 
652
               break;
 
653
            default:
 
654
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
 
655
               return;
 
656
         }
 
657
         break;
 
658
      case GL_DOMAIN:
 
659
         switch (target) {
 
660
            case GL_MAP1_COLOR_4:
 
661
               v[0] = ctx->EvalMap.Map1Color4.u1;
 
662
               v[1] = ctx->EvalMap.Map1Color4.u2;
 
663
               break;
 
664
            case GL_MAP1_INDEX:
 
665
               v[0] = ctx->EvalMap.Map1Index.u1;
 
666
               v[1] = ctx->EvalMap.Map1Index.u2;
 
667
               break;
 
668
            case GL_MAP1_NORMAL:
 
669
               v[0] = ctx->EvalMap.Map1Normal.u1;
 
670
               v[1] = ctx->EvalMap.Map1Normal.u2;
 
671
               break;
 
672
            case GL_MAP1_TEXTURE_COORD_1:
 
673
               v[0] = ctx->EvalMap.Map1Texture1.u1;
 
674
               v[1] = ctx->EvalMap.Map1Texture1.u2;
 
675
               break;
 
676
            case GL_MAP1_TEXTURE_COORD_2:
 
677
               v[0] = ctx->EvalMap.Map1Texture2.u1;
 
678
               v[1] = ctx->EvalMap.Map1Texture2.u2;
 
679
               break;
 
680
            case GL_MAP1_TEXTURE_COORD_3:
 
681
               v[0] = ctx->EvalMap.Map1Texture3.u1;
 
682
               v[1] = ctx->EvalMap.Map1Texture3.u2;
 
683
               break;
 
684
            case GL_MAP1_TEXTURE_COORD_4:
 
685
               v[0] = ctx->EvalMap.Map1Texture4.u1;
 
686
               v[1] = ctx->EvalMap.Map1Texture4.u2;
 
687
               break;
 
688
            case GL_MAP1_VERTEX_3:
 
689
               v[0] = ctx->EvalMap.Map1Vertex3.u1;
 
690
               v[1] = ctx->EvalMap.Map1Vertex3.u2;
 
691
               break;
 
692
            case GL_MAP1_VERTEX_4:
 
693
               v[0] = ctx->EvalMap.Map1Vertex4.u1;
 
694
               v[1] = ctx->EvalMap.Map1Vertex4.u2;
 
695
               break;
 
696
            case GL_MAP2_COLOR_4:
 
697
               v[0] = ctx->EvalMap.Map2Color4.u1;
 
698
               v[1] = ctx->EvalMap.Map2Color4.u2;
 
699
               v[2] = ctx->EvalMap.Map2Color4.v1;
 
700
               v[3] = ctx->EvalMap.Map2Color4.v2;
 
701
               break;
 
702
            case GL_MAP2_INDEX:
 
703
               v[0] = ctx->EvalMap.Map2Index.u1;
 
704
               v[1] = ctx->EvalMap.Map2Index.u2;
 
705
               v[2] = ctx->EvalMap.Map2Index.v1;
 
706
               v[3] = ctx->EvalMap.Map2Index.v2;
 
707
               break;
 
708
            case GL_MAP2_NORMAL:
 
709
               v[0] = ctx->EvalMap.Map2Normal.u1;
 
710
               v[1] = ctx->EvalMap.Map2Normal.u2;
 
711
               v[2] = ctx->EvalMap.Map2Normal.v1;
 
712
               v[3] = ctx->EvalMap.Map2Normal.v2;
 
713
               break;
 
714
            case GL_MAP2_TEXTURE_COORD_1:
 
715
               v[0] = ctx->EvalMap.Map2Texture1.u1;
 
716
               v[1] = ctx->EvalMap.Map2Texture1.u2;
 
717
               v[2] = ctx->EvalMap.Map2Texture1.v1;
 
718
               v[3] = ctx->EvalMap.Map2Texture1.v2;
 
719
               break;
 
720
            case GL_MAP2_TEXTURE_COORD_2:
 
721
               v[0] = ctx->EvalMap.Map2Texture2.u1;
 
722
               v[1] = ctx->EvalMap.Map2Texture2.u2;
 
723
               v[2] = ctx->EvalMap.Map2Texture2.v1;
 
724
               v[3] = ctx->EvalMap.Map2Texture2.v2;
 
725
               break;
 
726
            case GL_MAP2_TEXTURE_COORD_3:
 
727
               v[0] = ctx->EvalMap.Map2Texture3.u1;
 
728
               v[1] = ctx->EvalMap.Map2Texture3.u2;
 
729
               v[2] = ctx->EvalMap.Map2Texture3.v1;
 
730
               v[3] = ctx->EvalMap.Map2Texture3.v2;
 
731
               break;
 
732
            case GL_MAP2_TEXTURE_COORD_4:
 
733
               v[0] = ctx->EvalMap.Map2Texture4.u1;
 
734
               v[1] = ctx->EvalMap.Map2Texture4.u2;
 
735
               v[2] = ctx->EvalMap.Map2Texture4.v1;
 
736
               v[3] = ctx->EvalMap.Map2Texture4.v2;
 
737
               break;
 
738
            case GL_MAP2_VERTEX_3:
 
739
               v[0] = ctx->EvalMap.Map2Vertex3.u1;
 
740
               v[1] = ctx->EvalMap.Map2Vertex3.u2;
 
741
               v[2] = ctx->EvalMap.Map2Vertex3.v1;
 
742
               v[3] = ctx->EvalMap.Map2Vertex3.v2;
 
743
               break;
 
744
            case GL_MAP2_VERTEX_4:
 
745
               v[0] = ctx->EvalMap.Map2Vertex4.u1;
 
746
               v[1] = ctx->EvalMap.Map2Vertex4.u2;
 
747
               v[2] = ctx->EvalMap.Map2Vertex4.v1;
 
748
               v[3] = ctx->EvalMap.Map2Vertex4.v2;
 
749
               break;
 
750
            default:
 
751
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
 
752
         }
 
753
         break;
 
754
      default:
 
755
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
 
756
   }
 
757
}
 
758
 
 
759
 
 
760
void
 
761
_mesa_GetMapfv( GLenum target, GLenum query, GLfloat *v )
 
762
{
 
763
   GET_CURRENT_CONTEXT(ctx);
 
764
   GLint i, n;
 
765
   GLfloat *data;
 
766
   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
767
 
 
768
   switch (query) {
 
769
      case GL_COEFF:
 
770
         switch (target) {
 
771
            case GL_MAP1_COLOR_4:
 
772
               data = ctx->EvalMap.Map1Color4.Points;
 
773
               n = ctx->EvalMap.Map1Color4.Order * 4;
 
774
               break;
 
775
            case GL_MAP1_INDEX:
 
776
               data = ctx->EvalMap.Map1Index.Points;
 
777
               n = ctx->EvalMap.Map1Index.Order;
 
778
               break;
 
779
            case GL_MAP1_NORMAL:
 
780
               data = ctx->EvalMap.Map1Normal.Points;
 
781
               n = ctx->EvalMap.Map1Normal.Order * 3;
 
782
               break;
 
783
            case GL_MAP1_TEXTURE_COORD_1:
 
784
               data = ctx->EvalMap.Map1Texture1.Points;
 
785
               n = ctx->EvalMap.Map1Texture1.Order * 1;
 
786
               break;
 
787
            case GL_MAP1_TEXTURE_COORD_2:
 
788
               data = ctx->EvalMap.Map1Texture2.Points;
 
789
               n = ctx->EvalMap.Map1Texture2.Order * 2;
 
790
               break;
 
791
            case GL_MAP1_TEXTURE_COORD_3:
 
792
               data = ctx->EvalMap.Map1Texture3.Points;
 
793
               n = ctx->EvalMap.Map1Texture3.Order * 3;
 
794
               break;
 
795
            case GL_MAP1_TEXTURE_COORD_4:
 
796
               data = ctx->EvalMap.Map1Texture4.Points;
 
797
               n = ctx->EvalMap.Map1Texture4.Order * 4;
 
798
               break;
 
799
            case GL_MAP1_VERTEX_3:
 
800
               data = ctx->EvalMap.Map1Vertex3.Points;
 
801
               n = ctx->EvalMap.Map1Vertex3.Order * 3;
 
802
               break;
 
803
            case GL_MAP1_VERTEX_4:
 
804
               data = ctx->EvalMap.Map1Vertex4.Points;
 
805
               n = ctx->EvalMap.Map1Vertex4.Order * 4;
 
806
               break;
 
807
            case GL_MAP2_COLOR_4:
 
808
               data = ctx->EvalMap.Map2Color4.Points;
 
809
               n = ctx->EvalMap.Map2Color4.Uorder
 
810
                 * ctx->EvalMap.Map2Color4.Vorder * 4;
 
811
               break;
 
812
            case GL_MAP2_INDEX:
 
813
               data = ctx->EvalMap.Map2Index.Points;
 
814
               n = ctx->EvalMap.Map2Index.Uorder
 
815
                 * ctx->EvalMap.Map2Index.Vorder;
 
816
               break;
 
817
            case GL_MAP2_NORMAL:
 
818
               data = ctx->EvalMap.Map2Normal.Points;
 
819
               n = ctx->EvalMap.Map2Normal.Uorder
 
820
                 * ctx->EvalMap.Map2Normal.Vorder * 3;
 
821
               break;
 
822
            case GL_MAP2_TEXTURE_COORD_1:
 
823
               data = ctx->EvalMap.Map2Texture1.Points;
 
824
               n = ctx->EvalMap.Map2Texture1.Uorder
 
825
                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
 
826
               break;
 
827
            case GL_MAP2_TEXTURE_COORD_2:
 
828
               data = ctx->EvalMap.Map2Texture2.Points;
 
829
               n = ctx->EvalMap.Map2Texture2.Uorder
 
830
                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
 
831
               break;
 
832
            case GL_MAP2_TEXTURE_COORD_3:
 
833
               data = ctx->EvalMap.Map2Texture3.Points;
 
834
               n = ctx->EvalMap.Map2Texture3.Uorder
 
835
                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
 
836
               break;
 
837
            case GL_MAP2_TEXTURE_COORD_4:
 
838
               data = ctx->EvalMap.Map2Texture4.Points;
 
839
               n = ctx->EvalMap.Map2Texture4.Uorder
 
840
                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
 
841
               break;
 
842
            case GL_MAP2_VERTEX_3:
 
843
               data = ctx->EvalMap.Map2Vertex3.Points;
 
844
               n = ctx->EvalMap.Map2Vertex3.Uorder
 
845
                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
 
846
               break;
 
847
            case GL_MAP2_VERTEX_4:
 
848
               data = ctx->EvalMap.Map2Vertex4.Points;
 
849
               n = ctx->EvalMap.Map2Vertex4.Uorder
 
850
                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
 
851
               break;
 
852
            default:
 
853
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
 
854
               return;
 
855
         }
 
856
         if (data) {
 
857
            for (i=0;i<n;i++) {
 
858
               v[i] = data[i];
 
859
            }
 
860
         }
 
861
         break;
 
862
      case GL_ORDER:
 
863
         switch (target) {
 
864
            case GL_MAP1_COLOR_4:
 
865
               *v = (GLfloat) ctx->EvalMap.Map1Color4.Order;
 
866
               break;
 
867
            case GL_MAP1_INDEX:
 
868
               *v = (GLfloat) ctx->EvalMap.Map1Index.Order;
 
869
               break;
 
870
            case GL_MAP1_NORMAL:
 
871
               *v = (GLfloat) ctx->EvalMap.Map1Normal.Order;
 
872
               break;
 
873
            case GL_MAP1_TEXTURE_COORD_1:
 
874
               *v = (GLfloat) ctx->EvalMap.Map1Texture1.Order;
 
875
               break;
 
876
            case GL_MAP1_TEXTURE_COORD_2:
 
877
               *v = (GLfloat) ctx->EvalMap.Map1Texture2.Order;
 
878
               break;
 
879
            case GL_MAP1_TEXTURE_COORD_3:
 
880
               *v = (GLfloat) ctx->EvalMap.Map1Texture3.Order;
 
881
               break;
 
882
            case GL_MAP1_TEXTURE_COORD_4:
 
883
               *v = (GLfloat) ctx->EvalMap.Map1Texture4.Order;
 
884
               break;
 
885
            case GL_MAP1_VERTEX_3:
 
886
               *v = (GLfloat) ctx->EvalMap.Map1Vertex3.Order;
 
887
               break;
 
888
            case GL_MAP1_VERTEX_4:
 
889
               *v = (GLfloat) ctx->EvalMap.Map1Vertex4.Order;
 
890
               break;
 
891
            case GL_MAP2_COLOR_4:
 
892
               v[0] = (GLfloat) ctx->EvalMap.Map2Color4.Uorder;
 
893
               v[1] = (GLfloat) ctx->EvalMap.Map2Color4.Vorder;
 
894
               break;
 
895
            case GL_MAP2_INDEX:
 
896
               v[0] = (GLfloat) ctx->EvalMap.Map2Index.Uorder;
 
897
               v[1] = (GLfloat) ctx->EvalMap.Map2Index.Vorder;
 
898
               break;
 
899
            case GL_MAP2_NORMAL:
 
900
               v[0] = (GLfloat) ctx->EvalMap.Map2Normal.Uorder;
 
901
               v[1] = (GLfloat) ctx->EvalMap.Map2Normal.Vorder;
 
902
               break;
 
903
            case GL_MAP2_TEXTURE_COORD_1:
 
904
               v[0] = (GLfloat) ctx->EvalMap.Map2Texture1.Uorder;
 
905
               v[1] = (GLfloat) ctx->EvalMap.Map2Texture1.Vorder;
 
906
               break;
 
907
            case GL_MAP2_TEXTURE_COORD_2:
 
908
               v[0] = (GLfloat) ctx->EvalMap.Map2Texture2.Uorder;
 
909
               v[1] = (GLfloat) ctx->EvalMap.Map2Texture2.Vorder;
 
910
               break;
 
911
            case GL_MAP2_TEXTURE_COORD_3:
 
912
               v[0] = (GLfloat) ctx->EvalMap.Map2Texture3.Uorder;
 
913
               v[1] = (GLfloat) ctx->EvalMap.Map2Texture3.Vorder;
 
914
               break;
 
915
            case GL_MAP2_TEXTURE_COORD_4:
 
916
               v[0] = (GLfloat) ctx->EvalMap.Map2Texture4.Uorder;
 
917
               v[1] = (GLfloat) ctx->EvalMap.Map2Texture4.Vorder;
 
918
               break;
 
919
            case GL_MAP2_VERTEX_3:
 
920
               v[0] = (GLfloat) ctx->EvalMap.Map2Vertex3.Uorder;
 
921
               v[1] = (GLfloat) ctx->EvalMap.Map2Vertex3.Vorder;
 
922
               break;
 
923
            case GL_MAP2_VERTEX_4:
 
924
               v[0] = (GLfloat) ctx->EvalMap.Map2Vertex4.Uorder;
 
925
               v[1] = (GLfloat) ctx->EvalMap.Map2Vertex4.Vorder;
 
926
               break;
 
927
            default:
 
928
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
 
929
               return;
 
930
         }
 
931
         break;
 
932
      case GL_DOMAIN:
 
933
         switch (target) {
 
934
            case GL_MAP1_COLOR_4:
 
935
               v[0] = ctx->EvalMap.Map1Color4.u1;
 
936
               v[1] = ctx->EvalMap.Map1Color4.u2;
 
937
               break;
 
938
            case GL_MAP1_INDEX:
 
939
               v[0] = ctx->EvalMap.Map1Index.u1;
 
940
               v[1] = ctx->EvalMap.Map1Index.u2;
 
941
               break;
 
942
            case GL_MAP1_NORMAL:
 
943
               v[0] = ctx->EvalMap.Map1Normal.u1;
 
944
               v[1] = ctx->EvalMap.Map1Normal.u2;
 
945
               break;
 
946
            case GL_MAP1_TEXTURE_COORD_1:
 
947
               v[0] = ctx->EvalMap.Map1Texture1.u1;
 
948
               v[1] = ctx->EvalMap.Map1Texture1.u2;
 
949
               break;
 
950
            case GL_MAP1_TEXTURE_COORD_2:
 
951
               v[0] = ctx->EvalMap.Map1Texture2.u1;
 
952
               v[1] = ctx->EvalMap.Map1Texture2.u2;
 
953
               break;
 
954
            case GL_MAP1_TEXTURE_COORD_3:
 
955
               v[0] = ctx->EvalMap.Map1Texture3.u1;
 
956
               v[1] = ctx->EvalMap.Map1Texture3.u2;
 
957
               break;
 
958
            case GL_MAP1_TEXTURE_COORD_4:
 
959
               v[0] = ctx->EvalMap.Map1Texture4.u1;
 
960
               v[1] = ctx->EvalMap.Map1Texture4.u2;
 
961
               break;
 
962
            case GL_MAP1_VERTEX_3:
 
963
               v[0] = ctx->EvalMap.Map1Vertex3.u1;
 
964
               v[1] = ctx->EvalMap.Map1Vertex3.u2;
 
965
               break;
 
966
            case GL_MAP1_VERTEX_4:
 
967
               v[0] = ctx->EvalMap.Map1Vertex4.u1;
 
968
               v[1] = ctx->EvalMap.Map1Vertex4.u2;
 
969
               break;
 
970
            case GL_MAP2_COLOR_4:
 
971
               v[0] = ctx->EvalMap.Map2Color4.u1;
 
972
               v[1] = ctx->EvalMap.Map2Color4.u2;
 
973
               v[2] = ctx->EvalMap.Map2Color4.v1;
 
974
               v[3] = ctx->EvalMap.Map2Color4.v2;
 
975
               break;
 
976
            case GL_MAP2_INDEX:
 
977
               v[0] = ctx->EvalMap.Map2Index.u1;
 
978
               v[1] = ctx->EvalMap.Map2Index.u2;
 
979
               v[2] = ctx->EvalMap.Map2Index.v1;
 
980
               v[3] = ctx->EvalMap.Map2Index.v2;
 
981
               break;
 
982
            case GL_MAP2_NORMAL:
 
983
               v[0] = ctx->EvalMap.Map2Normal.u1;
 
984
               v[1] = ctx->EvalMap.Map2Normal.u2;
 
985
               v[2] = ctx->EvalMap.Map2Normal.v1;
 
986
               v[3] = ctx->EvalMap.Map2Normal.v2;
 
987
               break;
 
988
            case GL_MAP2_TEXTURE_COORD_1:
 
989
               v[0] = ctx->EvalMap.Map2Texture1.u1;
 
990
               v[1] = ctx->EvalMap.Map2Texture1.u2;
 
991
               v[2] = ctx->EvalMap.Map2Texture1.v1;
 
992
               v[3] = ctx->EvalMap.Map2Texture1.v2;
 
993
               break;
 
994
            case GL_MAP2_TEXTURE_COORD_2:
 
995
               v[0] = ctx->EvalMap.Map2Texture2.u1;
 
996
               v[1] = ctx->EvalMap.Map2Texture2.u2;
 
997
               v[2] = ctx->EvalMap.Map2Texture2.v1;
 
998
               v[3] = ctx->EvalMap.Map2Texture2.v2;
 
999
               break;
 
1000
            case GL_MAP2_TEXTURE_COORD_3:
 
1001
               v[0] = ctx->EvalMap.Map2Texture3.u1;
 
1002
               v[1] = ctx->EvalMap.Map2Texture3.u2;
 
1003
               v[2] = ctx->EvalMap.Map2Texture3.v1;
 
1004
               v[3] = ctx->EvalMap.Map2Texture3.v2;
 
1005
               break;
 
1006
            case GL_MAP2_TEXTURE_COORD_4:
 
1007
               v[0] = ctx->EvalMap.Map2Texture4.u1;
 
1008
               v[1] = ctx->EvalMap.Map2Texture4.u2;
 
1009
               v[2] = ctx->EvalMap.Map2Texture4.v1;
 
1010
               v[3] = ctx->EvalMap.Map2Texture4.v2;
 
1011
               break;
 
1012
            case GL_MAP2_VERTEX_3:
 
1013
               v[0] = ctx->EvalMap.Map2Vertex3.u1;
 
1014
               v[1] = ctx->EvalMap.Map2Vertex3.u2;
 
1015
               v[2] = ctx->EvalMap.Map2Vertex3.v1;
 
1016
               v[3] = ctx->EvalMap.Map2Vertex3.v2;
 
1017
               break;
 
1018
            case GL_MAP2_VERTEX_4:
 
1019
               v[0] = ctx->EvalMap.Map2Vertex4.u1;
 
1020
               v[1] = ctx->EvalMap.Map2Vertex4.u2;
 
1021
               v[2] = ctx->EvalMap.Map2Vertex4.v1;
 
1022
               v[3] = ctx->EvalMap.Map2Vertex4.v2;
 
1023
               break;
 
1024
            default:
 
1025
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
 
1026
         }
 
1027
         break;
 
1028
      default:
 
1029
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
 
1030
   }
 
1031
}
 
1032
 
 
1033
 
 
1034
void
 
1035
_mesa_GetMapiv( GLenum target, GLenum query, GLint *v )
 
1036
{
 
1037
   GET_CURRENT_CONTEXT(ctx);
 
1038
   GLuint i, n;
 
1039
   GLfloat *data;
 
1040
   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
1041
 
 
1042
   switch (query) {
 
1043
      case GL_COEFF:
 
1044
         switch (target) {
 
1045
            case GL_MAP1_COLOR_4:
 
1046
               data = ctx->EvalMap.Map1Color4.Points;
 
1047
               n = ctx->EvalMap.Map1Color4.Order * 4;
 
1048
               break;
 
1049
            case GL_MAP1_INDEX:
 
1050
               data = ctx->EvalMap.Map1Index.Points;
 
1051
               n = ctx->EvalMap.Map1Index.Order;
 
1052
               break;
 
1053
            case GL_MAP1_NORMAL:
 
1054
               data = ctx->EvalMap.Map1Normal.Points;
 
1055
               n = ctx->EvalMap.Map1Normal.Order * 3;
 
1056
               break;
 
1057
            case GL_MAP1_TEXTURE_COORD_1:
 
1058
               data = ctx->EvalMap.Map1Texture1.Points;
 
1059
               n = ctx->EvalMap.Map1Texture1.Order * 1;
 
1060
               break;
 
1061
            case GL_MAP1_TEXTURE_COORD_2:
 
1062
               data = ctx->EvalMap.Map1Texture2.Points;
 
1063
               n = ctx->EvalMap.Map1Texture2.Order * 2;
 
1064
               break;
 
1065
            case GL_MAP1_TEXTURE_COORD_3:
 
1066
               data = ctx->EvalMap.Map1Texture3.Points;
 
1067
               n = ctx->EvalMap.Map1Texture3.Order * 3;
 
1068
               break;
 
1069
            case GL_MAP1_TEXTURE_COORD_4:
 
1070
               data = ctx->EvalMap.Map1Texture4.Points;
 
1071
               n = ctx->EvalMap.Map1Texture4.Order * 4;
 
1072
               break;
 
1073
            case GL_MAP1_VERTEX_3:
 
1074
               data = ctx->EvalMap.Map1Vertex3.Points;
 
1075
               n = ctx->EvalMap.Map1Vertex3.Order * 3;
 
1076
               break;
 
1077
            case GL_MAP1_VERTEX_4:
 
1078
               data = ctx->EvalMap.Map1Vertex4.Points;
 
1079
               n = ctx->EvalMap.Map1Vertex4.Order * 4;
 
1080
               break;
 
1081
            case GL_MAP2_COLOR_4:
 
1082
               data = ctx->EvalMap.Map2Color4.Points;
 
1083
               n = ctx->EvalMap.Map2Color4.Uorder
 
1084
                 * ctx->EvalMap.Map2Color4.Vorder * 4;
 
1085
               break;
 
1086
            case GL_MAP2_INDEX:
 
1087
               data = ctx->EvalMap.Map2Index.Points;
 
1088
               n = ctx->EvalMap.Map2Index.Uorder
 
1089
                 * ctx->EvalMap.Map2Index.Vorder;
 
1090
               break;
 
1091
            case GL_MAP2_NORMAL:
 
1092
               data = ctx->EvalMap.Map2Normal.Points;
 
1093
               n = ctx->EvalMap.Map2Normal.Uorder
 
1094
                 * ctx->EvalMap.Map2Normal.Vorder * 3;
 
1095
               break;
 
1096
            case GL_MAP2_TEXTURE_COORD_1:
 
1097
               data = ctx->EvalMap.Map2Texture1.Points;
 
1098
               n = ctx->EvalMap.Map2Texture1.Uorder
 
1099
                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
 
1100
               break;
 
1101
            case GL_MAP2_TEXTURE_COORD_2:
 
1102
               data = ctx->EvalMap.Map2Texture2.Points;
 
1103
               n = ctx->EvalMap.Map2Texture2.Uorder
 
1104
                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
 
1105
               break;
 
1106
            case GL_MAP2_TEXTURE_COORD_3:
 
1107
               data = ctx->EvalMap.Map2Texture3.Points;
 
1108
               n = ctx->EvalMap.Map2Texture3.Uorder
 
1109
                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
 
1110
               break;
 
1111
            case GL_MAP2_TEXTURE_COORD_4:
 
1112
               data = ctx->EvalMap.Map2Texture4.Points;
 
1113
               n = ctx->EvalMap.Map2Texture4.Uorder
 
1114
                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
 
1115
               break;
 
1116
            case GL_MAP2_VERTEX_3:
 
1117
               data = ctx->EvalMap.Map2Vertex3.Points;
 
1118
               n = ctx->EvalMap.Map2Vertex3.Uorder
 
1119
                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
 
1120
               break;
 
1121
            case GL_MAP2_VERTEX_4:
 
1122
               data = ctx->EvalMap.Map2Vertex4.Points;
 
1123
               n = ctx->EvalMap.Map2Vertex4.Uorder
 
1124
                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
 
1125
               break;
 
1126
            default:
 
1127
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
 
1128
               return;
 
1129
         }
 
1130
         if (data) {
 
1131
            for (i=0;i<n;i++) {
 
1132
               v[i] = ROUNDF(data[i]);
 
1133
            }
 
1134
         }
 
1135
         break;
 
1136
      case GL_ORDER:
 
1137
         switch (target) {
 
1138
            case GL_MAP1_COLOR_4:
 
1139
               *v = ctx->EvalMap.Map1Color4.Order;
 
1140
               break;
 
1141
            case GL_MAP1_INDEX:
 
1142
               *v = ctx->EvalMap.Map1Index.Order;
 
1143
               break;
 
1144
            case GL_MAP1_NORMAL:
 
1145
               *v = ctx->EvalMap.Map1Normal.Order;
 
1146
               break;
 
1147
            case GL_MAP1_TEXTURE_COORD_1:
 
1148
               *v = ctx->EvalMap.Map1Texture1.Order;
 
1149
               break;
 
1150
            case GL_MAP1_TEXTURE_COORD_2:
 
1151
               *v = ctx->EvalMap.Map1Texture2.Order;
 
1152
               break;
 
1153
            case GL_MAP1_TEXTURE_COORD_3:
 
1154
               *v = ctx->EvalMap.Map1Texture3.Order;
 
1155
               break;
 
1156
            case GL_MAP1_TEXTURE_COORD_4:
 
1157
               *v = ctx->EvalMap.Map1Texture4.Order;
 
1158
               break;
 
1159
            case GL_MAP1_VERTEX_3:
 
1160
               *v = ctx->EvalMap.Map1Vertex3.Order;
 
1161
               break;
 
1162
            case GL_MAP1_VERTEX_4:
 
1163
               *v = ctx->EvalMap.Map1Vertex4.Order;
 
1164
               break;
 
1165
            case GL_MAP2_COLOR_4:
 
1166
               v[0] = ctx->EvalMap.Map2Color4.Uorder;
 
1167
               v[1] = ctx->EvalMap.Map2Color4.Vorder;
 
1168
               break;
 
1169
            case GL_MAP2_INDEX:
 
1170
               v[0] = ctx->EvalMap.Map2Index.Uorder;
 
1171
               v[1] = ctx->EvalMap.Map2Index.Vorder;
 
1172
               break;
 
1173
            case GL_MAP2_NORMAL:
 
1174
               v[0] = ctx->EvalMap.Map2Normal.Uorder;
 
1175
               v[1] = ctx->EvalMap.Map2Normal.Vorder;
 
1176
               break;
 
1177
            case GL_MAP2_TEXTURE_COORD_1:
 
1178
               v[0] = ctx->EvalMap.Map2Texture1.Uorder;
 
1179
               v[1] = ctx->EvalMap.Map2Texture1.Vorder;
 
1180
               break;
 
1181
            case GL_MAP2_TEXTURE_COORD_2:
 
1182
               v[0] = ctx->EvalMap.Map2Texture2.Uorder;
 
1183
               v[1] = ctx->EvalMap.Map2Texture2.Vorder;
 
1184
               break;
 
1185
            case GL_MAP2_TEXTURE_COORD_3:
 
1186
               v[0] = ctx->EvalMap.Map2Texture3.Uorder;
 
1187
               v[1] = ctx->EvalMap.Map2Texture3.Vorder;
 
1188
               break;
 
1189
            case GL_MAP2_TEXTURE_COORD_4:
 
1190
               v[0] = ctx->EvalMap.Map2Texture4.Uorder;
 
1191
               v[1] = ctx->EvalMap.Map2Texture4.Vorder;
 
1192
               break;
 
1193
            case GL_MAP2_VERTEX_3:
 
1194
               v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
 
1195
               v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
 
1196
               break;
 
1197
            case GL_MAP2_VERTEX_4:
 
1198
               v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
 
1199
               v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
 
1200
               break;
 
1201
            default:
 
1202
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
 
1203
               return;
 
1204
         }
 
1205
         break;
 
1206
      case GL_DOMAIN:
 
1207
         switch (target) {
 
1208
            case GL_MAP1_COLOR_4:
 
1209
               v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
 
1210
               v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
 
1211
               break;
 
1212
            case GL_MAP1_INDEX:
 
1213
               v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
 
1214
               v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
 
1215
               break;
 
1216
            case GL_MAP1_NORMAL:
 
1217
               v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
 
1218
               v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
 
1219
               break;
 
1220
            case GL_MAP1_TEXTURE_COORD_1:
 
1221
               v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
 
1222
               v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
 
1223
               break;
 
1224
            case GL_MAP1_TEXTURE_COORD_2:
 
1225
               v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
 
1226
               v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
 
1227
               break;
 
1228
            case GL_MAP1_TEXTURE_COORD_3:
 
1229
               v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
 
1230
               v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
 
1231
               break;
 
1232
            case GL_MAP1_TEXTURE_COORD_4:
 
1233
               v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
 
1234
               v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
 
1235
               break;
 
1236
            case GL_MAP1_VERTEX_3:
 
1237
               v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
 
1238
               v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
 
1239
               break;
 
1240
            case GL_MAP1_VERTEX_4:
 
1241
               v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
 
1242
               v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
 
1243
               break;
 
1244
            case GL_MAP2_COLOR_4:
 
1245
               v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
 
1246
               v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
 
1247
               v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
 
1248
               v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
 
1249
               break;
 
1250
            case GL_MAP2_INDEX:
 
1251
               v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
 
1252
               v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
 
1253
               v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
 
1254
               v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
 
1255
               break;
 
1256
            case GL_MAP2_NORMAL:
 
1257
               v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
 
1258
               v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
 
1259
               v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
 
1260
               v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
 
1261
               break;
 
1262
            case GL_MAP2_TEXTURE_COORD_1:
 
1263
               v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
 
1264
               v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
 
1265
               v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
 
1266
               v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
 
1267
               break;
 
1268
            case GL_MAP2_TEXTURE_COORD_2:
 
1269
               v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
 
1270
               v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
 
1271
               v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
 
1272
               v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
 
1273
               break;
 
1274
            case GL_MAP2_TEXTURE_COORD_3:
 
1275
               v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
 
1276
               v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
 
1277
               v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
 
1278
               v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
 
1279
               break;
 
1280
            case GL_MAP2_TEXTURE_COORD_4:
 
1281
               v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
 
1282
               v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
 
1283
               v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
 
1284
               v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
 
1285
               break;
 
1286
            case GL_MAP2_VERTEX_3:
 
1287
               v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
 
1288
               v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
 
1289
               v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
 
1290
               v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
 
1291
               break;
 
1292
            case GL_MAP2_VERTEX_4:
 
1293
               v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
 
1294
               v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
 
1295
               v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
 
1296
               v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
 
1297
               break;
 
1298
            default:
 
1299
               _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
 
1300
         }
 
1301
         break;
 
1302
      default:
 
1303
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
 
1304
   }
 
1305
}
 
1306
 
 
1307
 
 
1308
 
 
1309
void
 
1310
_mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
 
1311
{
 
1312
   GET_CURRENT_CONTEXT(ctx);
 
1313
   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
1314
 
 
1315
   if (un<1) {
 
1316
      _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
 
1317
      return;
 
1318
   }
 
1319
   FLUSH_VERTICES(ctx, _NEW_EVAL);
 
1320
   ctx->Eval.MapGrid1un = un;
 
1321
   ctx->Eval.MapGrid1u1 = u1;
 
1322
   ctx->Eval.MapGrid1u2 = u2;
 
1323
   ctx->Eval.MapGrid1du = (u2 - u1) / (GLfloat) un;
 
1324
}
 
1325
 
 
1326
 
 
1327
void
 
1328
_mesa_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
 
1329
{
 
1330
   _mesa_MapGrid1f( un, (GLfloat) u1, (GLfloat) u2 );
 
1331
}
 
1332
 
 
1333
 
 
1334
void
 
1335
_mesa_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
 
1336
                 GLint vn, GLfloat v1, GLfloat v2 )
 
1337
{
 
1338
   GET_CURRENT_CONTEXT(ctx);
 
1339
   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
1340
 
 
1341
   if (un<1) {
 
1342
      _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
 
1343
      return;
 
1344
   }
 
1345
   if (vn<1) {
 
1346
      _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
 
1347
      return;
 
1348
   }
 
1349
 
 
1350
   FLUSH_VERTICES(ctx, _NEW_EVAL);
 
1351
   ctx->Eval.MapGrid2un = un;
 
1352
   ctx->Eval.MapGrid2u1 = u1;
 
1353
   ctx->Eval.MapGrid2u2 = u2;
 
1354
   ctx->Eval.MapGrid2du = (u2 - u1) / (GLfloat) un;
 
1355
   ctx->Eval.MapGrid2vn = vn;
 
1356
   ctx->Eval.MapGrid2v1 = v1;
 
1357
   ctx->Eval.MapGrid2v2 = v2;
 
1358
   ctx->Eval.MapGrid2dv = (v2 - v1) / (GLfloat) vn;
 
1359
}
 
1360
 
 
1361
 
 
1362
void
 
1363
_mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
 
1364
                 GLint vn, GLdouble v1, GLdouble v2 )
 
1365
{
 
1366
   _mesa_MapGrid2f( un, (GLfloat) u1, (GLfloat) u2, 
 
1367
                    vn, (GLfloat) v1, (GLfloat) v2 );
 
1368
}