← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/mesa/main/api_noop.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/main/api_noop.c
1
 
/*
2
 
 * Mesa 3-D graphics library
3
 
 * Version:  6.5.1
4
 
 *
5
 
 * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
6
 
 *
7
 
 * Permission is hereby granted, free of charge, to any person obtaining a
8
 
 * copy of this software and associated documentation files (the "Software"),
9
 
 * to deal in the Software without restriction, including without limitation
10
 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11
 
 * and/or sell copies of the Software, and to permit persons to whom the
12
 
 * Software is furnished to do so, subject to the following conditions:
13
 
 *
14
 
 * The above copyright notice and this permission notice shall be included
15
 
 * in all copies or substantial portions of the Software.
16
 
 *
17
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18
 
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20
 
 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21
 
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22
 
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23
 
 */
24
 
 
25
 
 
26
 
#include "glheader.h"
27
 
#include "api_noop.h"
28
 
#include "api_validate.h"
29
 
#include "api_arrayelt.h"
30
 
#include "context.h"
31
 
#include "light.h"
32
 
#include "macros.h"
33
 
#include "mfeatures.h"
34
 
#include "dlist.h"
35
 
#include "eval.h"
36
 
#include "main/dispatch.h"
37
 
 
38
 
 
39
 
/**
40
 
 * \file
41
 
 * Just update the ctx->Current vertex attributes.
42
 
 * These functions are used when outside glBegin/glEnd or outside display
43
 
 * lists.
44
 
 */
45
 
 
46
 
 
47
 
#if FEATURE_beginend
48
 
 
49
 
 
50
 
static void GLAPIENTRY _mesa_noop_EdgeFlag( GLboolean b )
51
 
{
52
 
   GET_CURRENT_CONTEXT(ctx);
53
 
   ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] = (GLfloat)b;
54
 
}
55
 
 
56
 
static void GLAPIENTRY _mesa_noop_Indexf( GLfloat f )
57
 
{
58
 
   GET_CURRENT_CONTEXT(ctx);
59
 
   ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0] = f;
60
 
}
61
 
 
62
 
static void GLAPIENTRY _mesa_noop_Indexfv( const GLfloat *v )
63
 
{
64
 
   GET_CURRENT_CONTEXT(ctx);
65
 
   ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0] = *v;
66
 
}
67
 
 
68
 
static void GLAPIENTRY _mesa_noop_FogCoordfEXT( GLfloat a )
69
 
{
70
 
   GET_CURRENT_CONTEXT(ctx);
71
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_FOG];
72
 
   dest[0] = a;
73
 
   dest[1] = 0.0;
74
 
   dest[2] = 0.0;
75
 
   dest[3] = 1.0;
76
 
}
77
 
 
78
 
static void GLAPIENTRY _mesa_noop_FogCoordfvEXT( const GLfloat *v )
79
 
{
80
 
   GET_CURRENT_CONTEXT(ctx);
81
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_FOG];
82
 
   dest[0] = v[0];
83
 
   dest[1] = 0.0;
84
 
   dest[2] = 0.0;
85
 
   dest[3] = 1.0;
86
 
}
87
 
 
88
 
static void GLAPIENTRY _mesa_noop_Normal3f( GLfloat a, GLfloat b, GLfloat c )
89
 
{
90
 
   GET_CURRENT_CONTEXT(ctx);
91
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
92
 
   dest[0] = a;
93
 
   dest[1] = b;
94
 
   dest[2] = c;
95
 
   dest[3] = 1.0;
96
 
}
97
 
 
98
 
static void GLAPIENTRY _mesa_noop_Normal3fv( const GLfloat *v )
99
 
{
100
 
   GET_CURRENT_CONTEXT(ctx);
101
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
102
 
   dest[0] = v[0];
103
 
   dest[1] = v[1];
104
 
   dest[2] = v[2];
105
 
   dest[3] = 1.0;
106
 
}
107
 
 
108
 
static void GLAPIENTRY _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
109
 
{
110
 
   GET_CURRENT_CONTEXT(ctx);
111
 
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
112
 
   color[0] = a;
113
 
   color[1] = b;
114
 
   color[2] = c;
115
 
   color[3] = d;
116
 
}
117
 
 
118
 
static void GLAPIENTRY _mesa_noop_Color4fv( const GLfloat *v )
119
 
{
120
 
   GET_CURRENT_CONTEXT(ctx);
121
 
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
122
 
   color[0] = v[0];
123
 
   color[1] = v[1];
124
 
   color[2] = v[2];
125
 
   color[3] = v[3];
126
 
}
127
 
 
128
 
static void GLAPIENTRY _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c )
129
 
{
130
 
   GET_CURRENT_CONTEXT(ctx);
131
 
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
132
 
   color[0] = a;
133
 
   color[1] = b;
134
 
   color[2] = c;
135
 
   color[3] = 1.0;
136
 
}
137
 
 
138
 
static void GLAPIENTRY _mesa_noop_Color3fv( const GLfloat *v )
139
 
{
140
 
   GET_CURRENT_CONTEXT(ctx);
141
 
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
142
 
   color[0] = v[0];
143
 
   color[1] = v[1];
144
 
   color[2] = v[2];
145
 
   color[3] = 1.0;
146
 
}
147
 
 
148
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a )
149
 
{
150
 
   GET_CURRENT_CONTEXT(ctx);
151
 
   GLuint unit = target - GL_TEXTURE0_ARB;
152
 
 
153
 
   /* unit is unsigned -- cannot be less than zero.
154
 
    */
155
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
156
 
   {
157
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
158
 
      dest[0] = a;
159
 
      dest[1] = 0;
160
 
      dest[2] = 0;
161
 
      dest[3] = 1;
162
 
   }
163
 
}
164
 
 
165
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord1fvARB( GLenum target, const GLfloat *v )
166
 
{
167
 
   GET_CURRENT_CONTEXT(ctx);
168
 
   GLuint unit = target - GL_TEXTURE0_ARB;
169
 
 
170
 
   /* unit is unsigned -- cannot be less than zero.
171
 
    */
172
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
173
 
   {
174
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
175
 
      dest[0] = v[0];
176
 
      dest[1] = 0;
177
 
      dest[2] = 0;
178
 
      dest[3] = 1;
179
 
   }
180
 
}
181
 
 
182
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord2fARB( GLenum target, GLfloat a, GLfloat b )
183
 
{
184
 
   GET_CURRENT_CONTEXT(ctx);
185
 
   GLuint unit = target - GL_TEXTURE0_ARB;
186
 
 
187
 
   /* unit is unsigned -- cannot be less than zero.
188
 
    */
189
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
190
 
   {
191
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
192
 
      dest[0] = a;
193
 
      dest[1] = b;
194
 
      dest[2] = 0;
195
 
      dest[3] = 1;
196
 
   }
197
 
}
198
 
 
199
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord2fvARB( GLenum target, const GLfloat *v )
200
 
{
201
 
   GET_CURRENT_CONTEXT(ctx);
202
 
   GLuint unit = target - GL_TEXTURE0_ARB;
203
 
 
204
 
   /* unit is unsigned -- cannot be less than zero.
205
 
    */
206
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
207
 
   {
208
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
209
 
      dest[0] = v[0];
210
 
      dest[1] = v[1];
211
 
      dest[2] = 0;
212
 
      dest[3] = 1;
213
 
   }
214
 
}
215
 
 
216
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord3fARB( GLenum target, GLfloat a, GLfloat b, GLfloat c)
217
 
{
218
 
   GET_CURRENT_CONTEXT(ctx);
219
 
   GLuint unit = target - GL_TEXTURE0_ARB;
220
 
 
221
 
   /* unit is unsigned -- cannot be less than zero.
222
 
    */
223
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
224
 
   {
225
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
226
 
      dest[0] = a;
227
 
      dest[1] = b;
228
 
      dest[2] = c;
229
 
      dest[3] = 1;
230
 
   }
231
 
}
232
 
 
233
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord3fvARB( GLenum target, const GLfloat *v )
234
 
{
235
 
   GET_CURRENT_CONTEXT(ctx);
236
 
   GLuint unit = target - GL_TEXTURE0_ARB;
237
 
 
238
 
   /* unit is unsigned -- cannot be less than zero.
239
 
    */
240
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
241
 
   {
242
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
243
 
      dest[0] = v[0];
244
 
      dest[1] = v[1];
245
 
      dest[2] = v[2];
246
 
      dest[3] = 1;
247
 
   }
248
 
}
249
 
 
250
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord4fARB( GLenum target, GLfloat a, GLfloat b,
251
 
                              GLfloat c, GLfloat d )
252
 
{
253
 
   GET_CURRENT_CONTEXT(ctx);
254
 
   GLuint unit = target - GL_TEXTURE0_ARB;
255
 
 
256
 
   /* unit is unsigned -- cannot be less than zero.
257
 
    */
258
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
259
 
   {
260
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
261
 
      dest[0] = a;
262
 
      dest[1] = b;
263
 
      dest[2] = c;
264
 
      dest[3] = d;
265
 
   }
266
 
}
267
 
 
268
 
static void GLAPIENTRY _mesa_noop_MultiTexCoord4fvARB( GLenum target, const GLfloat *v )
269
 
{
270
 
   GET_CURRENT_CONTEXT(ctx);
271
 
   GLuint unit = target - GL_TEXTURE0_ARB;
272
 
 
273
 
   /* unit is unsigned -- cannot be less than zero.
274
 
    */
275
 
   if (unit < MAX_TEXTURE_COORD_UNITS)
276
 
   {
277
 
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
278
 
      dest[0] = v[0];
279
 
      dest[1] = v[1];
280
 
      dest[2] = v[2];
281
 
      dest[3] = v[3];
282
 
   }
283
 
}
284
 
 
285
 
static void GLAPIENTRY _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c )
286
 
{
287
 
   GET_CURRENT_CONTEXT(ctx);
288
 
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
289
 
   color[0] = a;
290
 
   color[1] = b;
291
 
   color[2] = c;
292
 
   color[3] = 1.0;
293
 
}
294
 
 
295
 
static void GLAPIENTRY _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v )
296
 
{
297
 
   GET_CURRENT_CONTEXT(ctx);
298
 
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
299
 
   color[0] = v[0];
300
 
   color[1] = v[1];
301
 
   color[2] = v[2];
302
 
   color[3] = 1.0;
303
 
}
304
 
 
305
 
static void GLAPIENTRY _mesa_noop_TexCoord1f( GLfloat a )
306
 
{
307
 
   GET_CURRENT_CONTEXT(ctx);
308
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
309
 
   dest[0] = a;
310
 
   dest[1] = 0;
311
 
   dest[2] = 0;
312
 
   dest[3] = 1;
313
 
}
314
 
 
315
 
static void GLAPIENTRY _mesa_noop_TexCoord1fv( const GLfloat *v )
316
 
{
317
 
   GET_CURRENT_CONTEXT(ctx);
318
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
319
 
   dest[0] = v[0];
320
 
   dest[1] = 0;
321
 
   dest[2] = 0;
322
 
   dest[3] = 1;
323
 
}
324
 
 
325
 
static void GLAPIENTRY _mesa_noop_TexCoord2f( GLfloat a, GLfloat b )
326
 
{
327
 
   GET_CURRENT_CONTEXT(ctx);
328
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
329
 
   dest[0] = a;
330
 
   dest[1] = b;
331
 
   dest[2] = 0;
332
 
   dest[3] = 1;
333
 
}
334
 
 
335
 
static void GLAPIENTRY _mesa_noop_TexCoord2fv( const GLfloat *v )
336
 
{
337
 
   GET_CURRENT_CONTEXT(ctx);
338
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
339
 
   dest[0] = v[0];
340
 
   dest[1] = v[1];
341
 
   dest[2] = 0;
342
 
   dest[3] = 1;
343
 
}
344
 
 
345
 
static void GLAPIENTRY _mesa_noop_TexCoord3f( GLfloat a, GLfloat b, GLfloat c )
346
 
{
347
 
   GET_CURRENT_CONTEXT(ctx);
348
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
349
 
   dest[0] = a;
350
 
   dest[1] = b;
351
 
   dest[2] = c;
352
 
   dest[3] = 1;
353
 
}
354
 
 
355
 
static void GLAPIENTRY _mesa_noop_TexCoord3fv( const GLfloat *v )
356
 
{
357
 
   GET_CURRENT_CONTEXT(ctx);
358
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
359
 
   dest[0] = v[0];
360
 
   dest[1] = v[1];
361
 
   dest[2] = v[2];
362
 
   dest[3] = 1;
363
 
}
364
 
 
365
 
static void GLAPIENTRY _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
366
 
{
367
 
   GET_CURRENT_CONTEXT(ctx);
368
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
369
 
   dest[0] = a;
370
 
   dest[1] = b;
371
 
   dest[2] = c;
372
 
   dest[3] = d;
373
 
}
374
 
 
375
 
static void GLAPIENTRY _mesa_noop_TexCoord4fv( const GLfloat *v )
376
 
{
377
 
   GET_CURRENT_CONTEXT(ctx);
378
 
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
379
 
   dest[0] = v[0];
380
 
   dest[1] = v[1];
381
 
   dest[2] = v[2];
382
 
   dest[3] = v[3];
383
 
}
384
 
 
385
 
 
386
 
/**
387
 
 * GL_NV_vertex_program attributes.
388
 
 * Note that these attributes alias the conventional vertex attributes.
389
 
 */
390
 
 
391
 
static void GLAPIENTRY _mesa_noop_VertexAttrib1fNV( GLuint index, GLfloat x )
392
 
{
393
 
   GET_CURRENT_CONTEXT(ctx);
394
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
395
 
      ASSIGN_4V(ctx->Current.Attrib[index], x, 0, 0, 1);
396
 
   }
397
 
   else
398
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fNV(index)" );
399
 
}
400
 
 
401
 
static void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v )
402
 
{
403
 
   GET_CURRENT_CONTEXT(ctx);
404
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
405
 
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], 0, 0, 1);
406
 
   }
407
 
   else
408
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fvNV(index)" );
409
 
}
410
 
 
411
 
static void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y )
412
 
{
413
 
   GET_CURRENT_CONTEXT(ctx);
414
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
415
 
      ASSIGN_4V(ctx->Current.Attrib[index], x, y, 0, 1);
416
 
   }
417
 
   else
418
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fNV(index)" );
419
 
}
420
 
 
421
 
static void GLAPIENTRY _mesa_noop_VertexAttrib2fvNV( GLuint index, const GLfloat *v )
422
 
{
423
 
   GET_CURRENT_CONTEXT(ctx);
424
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
425
 
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], 0, 1);
426
 
   }
427
 
   else
428
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fvNV(index)" );
429
 
}
430
 
 
431
 
static void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x,
432
 
                                  GLfloat y, GLfloat z )
433
 
{
434
 
   GET_CURRENT_CONTEXT(ctx);
435
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
436
 
      ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, 1);
437
 
   }
438
 
   else
439
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fNV(index)" );
440
 
}
441
 
 
442
 
static void GLAPIENTRY _mesa_noop_VertexAttrib3fvNV( GLuint index, const GLfloat *v )
443
 
{
444
 
   GET_CURRENT_CONTEXT(ctx);
445
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
446
 
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], 1);
447
 
   }
448
 
   else
449
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fvNV(index)" );
450
 
}
451
 
 
452
 
static void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x,
453
 
                                  GLfloat y, GLfloat z, GLfloat w )
454
 
{
455
 
   GET_CURRENT_CONTEXT(ctx);
456
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
457
 
      ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w);
458
 
   }
459
 
   else
460
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fNV(index)" );
461
 
}
462
 
 
463
 
static void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
464
 
{
465
 
   GET_CURRENT_CONTEXT(ctx);
466
 
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
467
 
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]);
468
 
   }
469
 
   else
470
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fvNV(index)" );
471
 
}
472
 
 
473
 
 
474
 
 
475
 
/**
476
 
 * GL_ARB_vertex_program attributes.
477
 
 * Note that these attributes DO NOT alias the conventional vertex attributes.
478
 
 */
479
 
 
480
 
static void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x )
481
 
{
482
 
   GET_CURRENT_CONTEXT(ctx);
483
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
484
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, 0, 0, 1);
485
 
   }
486
 
   else
487
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fARB(index)" );
488
 
}
489
 
 
490
 
static void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v )
491
 
{
492
 
   GET_CURRENT_CONTEXT(ctx);
493
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
494
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], 0, 0, 1);
495
 
   }
496
 
   else
497
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fvARB(index)" );
498
 
}
499
 
 
500
 
static void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
501
 
{
502
 
   GET_CURRENT_CONTEXT(ctx);
503
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
504
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, 0, 1);
505
 
   }
506
 
   else
507
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fARB(index)" );
508
 
}
509
 
 
510
 
static void GLAPIENTRY _mesa_noop_VertexAttrib2fvARB( GLuint index, const GLfloat *v )
511
 
{
512
 
   GET_CURRENT_CONTEXT(ctx);
513
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
514
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], 0, 1);
515
 
   }
516
 
   else
517
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fvARB(index)" );
518
 
}
519
 
 
520
 
static void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x,
521
 
                                  GLfloat y, GLfloat z )
522
 
{
523
 
   GET_CURRENT_CONTEXT(ctx);
524
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
525
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, 1);
526
 
   }
527
 
   else
528
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fARB(index)" );
529
 
}
530
 
 
531
 
static void GLAPIENTRY _mesa_noop_VertexAttrib3fvARB( GLuint index, const GLfloat *v )
532
 
{
533
 
   GET_CURRENT_CONTEXT(ctx);
534
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
535
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], 1);
536
 
   }
537
 
   else
538
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fvARB(index)" );
539
 
}
540
 
 
541
 
static void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x,
542
 
                                  GLfloat y, GLfloat z, GLfloat w )
543
 
{
544
 
   GET_CURRENT_CONTEXT(ctx);
545
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
546
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, w);
547
 
   }
548
 
   else
549
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fARB(index)" );
550
 
}
551
 
 
552
 
static void GLAPIENTRY _mesa_noop_VertexAttrib4fvARB( GLuint index, const GLfloat *v )
553
 
{
554
 
   GET_CURRENT_CONTEXT(ctx);
555
 
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
556
 
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], v[3]);
557
 
   }
558
 
   else
559
 
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fvARB(index)" );
560
 
}
561
 
 
562
 
 
563
 
 
564
 
/**
565
 
 * Called by glMaterial*()
566
 
 */
567
 
void GLAPIENTRY
568
 
_mesa_noop_Materialfv( GLenum face, GLenum pname, const GLfloat *params )
569
 
{
570
 
   GET_CURRENT_CONTEXT(ctx);
571
 
   GLint i, nr;
572
 
   struct gl_material *mat = &ctx->Light.Material;
573
 
   GLuint bitmask = _mesa_material_bitmask( ctx, face, pname, ~0,
574
 
                                            "_mesa_noop_Materialfv" );
575
 
 
576
 
   if (ctx->Light.ColorMaterialEnabled)
577
 
      bitmask &= ~ctx->Light.ColorMaterialBitmask;
578
 
 
579
 
   if (bitmask == 0)
580
 
      return;
581
 
 
582
 
   switch (pname) {
583
 
   case GL_SHININESS: nr = 1; break;
584
 
   case GL_COLOR_INDEXES: nr = 3; break;
585
 
   default: nr = 4 ; break;
586
 
   }
587
 
 
588
 
   for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) 
589
 
      if (bitmask & (1<<i))
590
 
         COPY_SZ_4V( mat->Attrib[i], nr, params ); 
591
 
 
592
 
   _mesa_update_material( ctx, bitmask );
593
 
}
594
 
 
595
 
 
596
 
/**
597
 
 * These really are noops outside begin/end:
598
 
 */
599
 
static void GLAPIENTRY _mesa_noop_Vertex2fv( const GLfloat *v )
600
 
{
601
 
   (void) v;
602
 
}
603
 
 
604
 
static void GLAPIENTRY _mesa_noop_Vertex3fv( const GLfloat *v )
605
 
{
606
 
   (void) v;
607
 
}
608
 
 
609
 
static void GLAPIENTRY _mesa_noop_Vertex4fv( const GLfloat *v )
610
 
{
611
 
   (void) v;
612
 
}
613
 
 
614
 
static void GLAPIENTRY _mesa_noop_Vertex2f( GLfloat a, GLfloat b )
615
 
{
616
 
   (void) a; (void) b;
617
 
}
618
 
 
619
 
static void GLAPIENTRY _mesa_noop_Vertex3f( GLfloat a, GLfloat b, GLfloat c )
620
 
{
621
 
   (void) a; (void) b; (void) c;
622
 
}
623
 
 
624
 
static void GLAPIENTRY _mesa_noop_Vertex4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
625
 
{
626
 
   (void) a; (void) b; (void) c; (void) d;
627
 
}
628
 
 
629
 
 
630
 
#if FEATURE_evaluators
631
 
/* Similarly, these have no effect outside begin/end:
632
 
 */
633
 
static void GLAPIENTRY _mesa_noop_EvalCoord1f( GLfloat a )
634
 
{
635
 
   (void) a;
636
 
}
637
 
 
638
 
static void GLAPIENTRY _mesa_noop_EvalCoord1fv( const GLfloat *v )
639
 
{
640
 
   (void) v;
641
 
}
642
 
 
643
 
static void GLAPIENTRY _mesa_noop_EvalCoord2f( GLfloat a, GLfloat b )
644
 
{
645
 
   (void) a; (void) b;
646
 
}
647
 
 
648
 
static void GLAPIENTRY _mesa_noop_EvalCoord2fv( const GLfloat *v )
649
 
{
650
 
   (void) v;
651
 
}
652
 
 
653
 
static void GLAPIENTRY _mesa_noop_EvalPoint1( GLint a )
654
 
{
655
 
   (void) a;
656
 
}
657
 
 
658
 
static void GLAPIENTRY _mesa_noop_EvalPoint2( GLint a, GLint b )
659
 
{
660
 
   (void) a; (void) b;
661
 
}
662
 
#endif /* FEATURE_evaluators */
663
 
 
664
 
 
665
 
/* Begin -- call into driver, should result in the vtxfmt being
666
 
 * swapped out:
667
 
 */
668
 
static void GLAPIENTRY _mesa_noop_Begin( GLenum mode )
669
 
{
670
 
   (void) mode;
671
 
}
672
 
 
673
 
 
674
 
/* End -- just raise an error
675
 
 */
676
 
static void GLAPIENTRY _mesa_noop_End( void )
677
 
{
678
 
   GET_CURRENT_CONTEXT(ctx);
679
 
   _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd(no glBegin)" );
680
 
}
681
 
 
682
 
 
683
 
/***
684
 
 * PrimitiveRestart called outside glBegin()/End(): raise an error
685
 
 */
686
 
static void GLAPIENTRY _mesa_noop_PrimitiveRestartNV( void )
687
 
{
688
 
   GET_CURRENT_CONTEXT(ctx);
689
 
   _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV(no glBegin)");
690
 
}
691
 
 
692
 
 
693
 
/**
694
 
 * Execute a glRectf() function.  This is not suitable for GL_COMPILE
695
 
 * modes (as the test for outside begin/end is not compiled),
696
 
 * but may be useful for drivers in circumstances which exclude
697
 
 * display list interactions.
698
 
 *
699
 
 * (None of the functions in this file are suitable for GL_COMPILE
700
 
 * modes).
701
 
 */
702
 
void GLAPIENTRY
703
 
_mesa_noop_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
704
 
{
705
 
   {
706
 
      GET_CURRENT_CONTEXT(ctx);
707
 
      ASSERT_OUTSIDE_BEGIN_END(ctx);
708
 
   }
709
 
 
710
 
   CALL_Begin(GET_DISPATCH(), (GL_QUADS));
711
 
   CALL_Vertex2f(GET_DISPATCH(), (x1, y1));
712
 
   CALL_Vertex2f(GET_DISPATCH(), (x2, y1));
713
 
   CALL_Vertex2f(GET_DISPATCH(), (x2, y2));
714
 
   CALL_Vertex2f(GET_DISPATCH(), (x1, y2));
715
 
   CALL_End(GET_DISPATCH(), ());
716
 
}
717
 
 
718
 
 
719
 
/**
720
 
 * Some very basic support for arrays.  Drivers without explicit array
721
 
 * support can hook these in, but still need to supply an array-elt
722
 
 * implementation.
723
 
 */
724
 
static void GLAPIENTRY
725
 
_mesa_noop_DrawArrays(GLenum mode, GLint start, GLsizei count)
726
 
{
727
 
   GET_CURRENT_CONTEXT(ctx);
728
 
   GLint i;
729
 
 
730
 
   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
731
 
      return;
732
 
 
733
 
   CALL_Begin(GET_DISPATCH(), (mode));
734
 
   for (i = 0; i < count; i++)
735
 
       CALL_ArrayElement(GET_DISPATCH(), (start + i));
736
 
   CALL_End(GET_DISPATCH(), ());
737
 
}
738
 
 
739
 
 
740
 
static void GLAPIENTRY
741
 
_mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
742
 
                        const GLvoid *indices)
743
 
{
744
 
   GET_CURRENT_CONTEXT(ctx);
745
 
   GLint i;
746
 
 
747
 
   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
748
 
      return;
749
 
 
750
 
   CALL_Begin(GET_DISPATCH(), (mode));
751
 
 
752
 
   switch (type) {
753
 
   case GL_UNSIGNED_BYTE:
754
 
      for (i = 0 ; i < count ; i++)
755
 
          CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] ));
756
 
      break;
757
 
   case GL_UNSIGNED_SHORT:
758
 
      for (i = 0 ; i < count ; i++)
759
 
          CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] ));
760
 
      break;
761
 
   case GL_UNSIGNED_INT:
762
 
      for (i = 0 ; i < count ; i++)
763
 
          CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] ));
764
 
      break;
765
 
   default:
766
 
      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
767
 
      break;
768
 
   }
769
 
 
770
 
   CALL_End(GET_DISPATCH(), ());
771
 
}
772
 
 
773
 
static void GLAPIENTRY
774
 
_mesa_noop_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
775
 
                                  const GLvoid *indices, GLint basevertex)
776
 
{
777
 
   GET_CURRENT_CONTEXT(ctx);
778
 
   GLint i;
779
 
 
780
 
   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
781
 
                                     basevertex ))
782
 
      return;
783
 
 
784
 
   CALL_Begin(GET_DISPATCH(), (mode));
785
 
 
786
 
   switch (type) {
787
 
   case GL_UNSIGNED_BYTE:
788
 
      for (i = 0 ; i < count ; i++)
789
 
          CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] +
790
 
                                              basevertex));
791
 
      break;
792
 
   case GL_UNSIGNED_SHORT:
793
 
      for (i = 0 ; i < count ; i++)
794
 
          CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] +
795
 
                                              basevertex ));
796
 
      break;
797
 
   case GL_UNSIGNED_INT:
798
 
      for (i = 0 ; i < count ; i++)
799
 
          CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] +
800
 
                                              basevertex ));
801
 
      break;
802
 
   default:
803
 
      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElementsBaseVertex(type)" );
804
 
      break;
805
 
   }
806
 
 
807
 
   CALL_End(GET_DISPATCH(), ());
808
 
}
809
 
 
810
 
 
811
 
static void GLAPIENTRY
812
 
_mesa_noop_DrawRangeElements(GLenum mode,
813
 
                             GLuint start, GLuint end,
814
 
                             GLsizei count, GLenum type,
815
 
                             const GLvoid *indices)
816
 
{
817
 
   GET_CURRENT_CONTEXT(ctx);
818
 
 
819
 
   if (_mesa_validate_DrawRangeElements( ctx, mode,
820
 
                                         start, end,
821
 
                                         count, type, indices, 0 ))
822
 
       CALL_DrawElements(GET_DISPATCH(), (mode, count, type, indices));
823
 
}
824
 
 
825
 
/* GL_EXT_multi_draw_arrays */
826
 
void GLAPIENTRY
827
 
_mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
828
 
                             const GLvoid **indices, GLsizei primcount)
829
 
{
830
 
   GLsizei i;
831
 
 
832
 
   for (i = 0; i < primcount; i++) {
833
 
      if (count[i] > 0) {
834
 
         CALL_DrawElements(GET_DISPATCH(), (mode, count[i], type, indices[i]));
835
 
      }
836
 
   }
837
 
}
838
 
 
839
 
static void GLAPIENTRY
840
 
_mesa_noop_DrawRangeElementsBaseVertex(GLenum mode,
841
 
                                       GLuint start, GLuint end,
842
 
                                       GLsizei count, GLenum type,
843
 
                                       const GLvoid *indices, GLint basevertex)
844
 
{
845
 
   GET_CURRENT_CONTEXT(ctx);
846
 
 
847
 
   if (_mesa_validate_DrawRangeElements( ctx, mode,
848
 
                                         start, end,
849
 
                                         count, type, indices, basevertex ))
850
 
      CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count, type, indices,
851
 
                                                   basevertex));
852
 
}
853
 
 
854
 
/* GL_EXT_multi_draw_arrays */
855
 
void GLAPIENTRY
856
 
_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
857
 
                                       GLenum type,
858
 
                                       const GLvoid **indices,
859
 
                                       GLsizei primcount,
860
 
                                       const GLint *basevertex)
861
 
{
862
 
   GLsizei i;
863
 
 
864
 
   for (i = 0; i < primcount; i++) {
865
 
      if (count[i] > 0) {
866
 
         CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count[i], type,
867
 
                                                      indices[i],
868
 
                                                      basevertex[i]));
869
 
      }
870
 
   }
871
 
}
872
 
 
873
 
/*
874
 
 * Eval Mesh
875
 
 */
876
 
 
877
 
/**
878
 
 * KW:
879
 
 * If are compiling, we don't know whether eval will produce a
880
 
 * vertex when it is run in the future.  If this is pure immediate
881
 
 * mode, eval is a noop if neither vertex map is enabled.
882
 
 *
883
 
 * Thus we need to have a check in the display list code or elsewhere
884
 
 * for eval(1,2) vertices in the case where map(1,2)_vertex is
885
 
 * disabled, and to purge those vertices from the vb.
886
 
 */
887
 
void GLAPIENTRY
888
 
_mesa_noop_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
889
 
{
890
 
   GET_CURRENT_CONTEXT(ctx);
891
 
   GLint i;
892
 
   GLfloat u, du;
893
 
   GLenum prim;
894
 
 
895
 
   switch (mode) {
896
 
   case GL_POINT:
897
 
      prim = GL_POINTS;
898
 
      break;
899
 
   case GL_LINE:
900
 
      prim = GL_LINE_STRIP;
901
 
      break;
902
 
   default:
903
 
      _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
904
 
      return;
905
 
   }
906
 
 
907
 
   /* No effect if vertex maps disabled.
908
 
    */
909
 
   if (!ctx->Eval.Map1Vertex4 && 
910
 
       !ctx->Eval.Map1Vertex3 &&
911
 
       !(ctx->VertexProgram._Enabled && ctx->Eval.Map1Attrib[VERT_ATTRIB_POS]))
912
 
      return;
913
 
 
914
 
   du = ctx->Eval.MapGrid1du;
915
 
   u = ctx->Eval.MapGrid1u1 + i1 * du;
916
 
 
917
 
   CALL_Begin(GET_DISPATCH(), (prim));
918
 
   for (i=i1;i<=i2;i++,u+=du) {
919
 
      CALL_EvalCoord1f(GET_DISPATCH(), (u));
920
 
   }
921
 
   CALL_End(GET_DISPATCH(), ());
922
 
}
923
 
 
924
 
 
925
 
 
926
 
void GLAPIENTRY
927
 
_mesa_noop_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
928
 
{
929
 
   GET_CURRENT_CONTEXT(ctx);
930
 
   GLfloat u, du, v, dv, v1, u1;
931
 
   GLint i, j;
932
 
 
933
 
   switch (mode) {
934
 
   case GL_POINT:
935
 
   case GL_LINE:
936
 
   case GL_FILL:
937
 
      break;
938
 
   default:
939
 
      _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
940
 
      return;
941
 
   }
942
 
 
943
 
   /* No effect if vertex maps disabled.
944
 
    */
945
 
   if (!ctx->Eval.Map2Vertex4 && 
946
 
       !ctx->Eval.Map2Vertex3 &&
947
 
       !(ctx->VertexProgram._Enabled && ctx->Eval.Map2Attrib[VERT_ATTRIB_POS]))
948
 
      return;
949
 
 
950
 
   du = ctx->Eval.MapGrid2du;
951
 
   dv = ctx->Eval.MapGrid2dv;
952
 
   v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
953
 
   u1 = ctx->Eval.MapGrid2u1 + i1 * du;
954
 
 
955
 
   switch (mode) {
956
 
   case GL_POINT:
957
 
      CALL_Begin(GET_DISPATCH(), (GL_POINTS));
958
 
      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
959
 
         for (u=u1,i=i1;i<=i2;i++,u+=du) {
960
 
            CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
961
 
         }
962
 
      }
963
 
      CALL_End(GET_DISPATCH(), ());
964
 
      break;
965
 
   case GL_LINE:
966
 
      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
967
 
         CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
968
 
         for (u=u1,i=i1;i<=i2;i++,u+=du) {
969
 
            CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
970
 
         }
971
 
         CALL_End(GET_DISPATCH(), ());
972
 
      }
973
 
      for (u=u1,i=i1;i<=i2;i++,u+=du) {
974
 
         CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
975
 
         for (v=v1,j=j1;j<=j2;j++,v+=dv) {
976
 
            CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
977
 
         }
978
 
         CALL_End(GET_DISPATCH(), ());
979
 
      }
980
 
      break;
981
 
   case GL_FILL:
982
 
      for (v=v1,j=j1;j<j2;j++,v+=dv) {
983
 
         CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP));
984
 
         for (u=u1,i=i1;i<=i2;i++,u+=du) {
985
 
            CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
986
 
            CALL_EvalCoord2f(GET_DISPATCH(), (u, v+dv));
987
 
         }
988
 
         CALL_End(GET_DISPATCH(), ());
989
 
      }
990
 
      break;
991
 
   default:
992
 
      _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
993
 
      return;
994
 
   }
995
 
}
996
 
 
997
 
 
998
 
 
999
 
/**
1000
 
 * Build a vertexformat of functions to use outside begin/end pairs.
1001
 
 * 
1002
 
 * TODO -- build a whole dispatch table for this purpose, and likewise
1003
 
 * for inside begin/end.
1004
 
 */
1005
 
void
1006
 
_mesa_noop_vtxfmt_init( GLvertexformat *vfmt )
1007
 
{
1008
 
   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
1009
 
 
1010
 
   vfmt->Begin = _mesa_noop_Begin;
1011
 
 
1012
 
   _MESA_INIT_DLIST_VTXFMT(vfmt, _mesa_);
1013
 
 
1014
 
   vfmt->Color3f = _mesa_noop_Color3f;
1015
 
   vfmt->Color3fv = _mesa_noop_Color3fv;
1016
 
   vfmt->Color4f = _mesa_noop_Color4f;
1017
 
   vfmt->Color4fv = _mesa_noop_Color4fv;
1018
 
   vfmt->EdgeFlag = _mesa_noop_EdgeFlag;
1019
 
   vfmt->End = _mesa_noop_End;
1020
 
 
1021
 
   vfmt->PrimitiveRestartNV = _mesa_noop_PrimitiveRestartNV;
1022
 
 
1023
 
   _MESA_INIT_EVAL_VTXFMT(vfmt, _mesa_noop_);
1024
 
 
1025
 
   vfmt->FogCoordfEXT = _mesa_noop_FogCoordfEXT;
1026
 
   vfmt->FogCoordfvEXT = _mesa_noop_FogCoordfvEXT;
1027
 
   vfmt->Indexf = _mesa_noop_Indexf;
1028
 
   vfmt->Indexfv = _mesa_noop_Indexfv;
1029
 
   vfmt->Materialfv = _mesa_noop_Materialfv;
1030
 
   vfmt->MultiTexCoord1fARB = _mesa_noop_MultiTexCoord1fARB;
1031
 
   vfmt->MultiTexCoord1fvARB = _mesa_noop_MultiTexCoord1fvARB;
1032
 
   vfmt->MultiTexCoord2fARB = _mesa_noop_MultiTexCoord2fARB;
1033
 
   vfmt->MultiTexCoord2fvARB = _mesa_noop_MultiTexCoord2fvARB;
1034
 
   vfmt->MultiTexCoord3fARB = _mesa_noop_MultiTexCoord3fARB;
1035
 
   vfmt->MultiTexCoord3fvARB = _mesa_noop_MultiTexCoord3fvARB;
1036
 
   vfmt->MultiTexCoord4fARB = _mesa_noop_MultiTexCoord4fARB;
1037
 
   vfmt->MultiTexCoord4fvARB = _mesa_noop_MultiTexCoord4fvARB;
1038
 
   vfmt->Normal3f = _mesa_noop_Normal3f;
1039
 
   vfmt->Normal3fv = _mesa_noop_Normal3fv;
1040
 
   vfmt->SecondaryColor3fEXT = _mesa_noop_SecondaryColor3fEXT;
1041
 
   vfmt->SecondaryColor3fvEXT = _mesa_noop_SecondaryColor3fvEXT;
1042
 
   vfmt->TexCoord1f = _mesa_noop_TexCoord1f;
1043
 
   vfmt->TexCoord1fv = _mesa_noop_TexCoord1fv;
1044
 
   vfmt->TexCoord2f = _mesa_noop_TexCoord2f;
1045
 
   vfmt->TexCoord2fv = _mesa_noop_TexCoord2fv;
1046
 
   vfmt->TexCoord3f = _mesa_noop_TexCoord3f;
1047
 
   vfmt->TexCoord3fv = _mesa_noop_TexCoord3fv;
1048
 
   vfmt->TexCoord4f = _mesa_noop_TexCoord4f;
1049
 
   vfmt->TexCoord4fv = _mesa_noop_TexCoord4fv;
1050
 
   vfmt->Vertex2f = _mesa_noop_Vertex2f;
1051
 
   vfmt->Vertex2fv = _mesa_noop_Vertex2fv;
1052
 
   vfmt->Vertex3f = _mesa_noop_Vertex3f;
1053
 
   vfmt->Vertex3fv = _mesa_noop_Vertex3fv;
1054
 
   vfmt->Vertex4f = _mesa_noop_Vertex4f;
1055
 
   vfmt->Vertex4fv = _mesa_noop_Vertex4fv;
1056
 
   vfmt->VertexAttrib1fNV = _mesa_noop_VertexAttrib1fNV;
1057
 
   vfmt->VertexAttrib1fvNV = _mesa_noop_VertexAttrib1fvNV;
1058
 
   vfmt->VertexAttrib2fNV = _mesa_noop_VertexAttrib2fNV;
1059
 
   vfmt->VertexAttrib2fvNV = _mesa_noop_VertexAttrib2fvNV;
1060
 
   vfmt->VertexAttrib3fNV = _mesa_noop_VertexAttrib3fNV;
1061
 
   vfmt->VertexAttrib3fvNV = _mesa_noop_VertexAttrib3fvNV;
1062
 
   vfmt->VertexAttrib4fNV = _mesa_noop_VertexAttrib4fNV;
1063
 
   vfmt->VertexAttrib4fvNV = _mesa_noop_VertexAttrib4fvNV;
1064
 
   vfmt->VertexAttrib1fARB = _mesa_noop_VertexAttrib1fARB;
1065
 
   vfmt->VertexAttrib1fvARB = _mesa_noop_VertexAttrib1fvARB;
1066
 
   vfmt->VertexAttrib2fARB = _mesa_noop_VertexAttrib2fARB;
1067
 
   vfmt->VertexAttrib2fvARB = _mesa_noop_VertexAttrib2fvARB;
1068
 
   vfmt->VertexAttrib3fARB = _mesa_noop_VertexAttrib3fARB;
1069
 
   vfmt->VertexAttrib3fvARB = _mesa_noop_VertexAttrib3fvARB;
1070
 
   vfmt->VertexAttrib4fARB = _mesa_noop_VertexAttrib4fARB;
1071
 
   vfmt->VertexAttrib4fvARB = _mesa_noop_VertexAttrib4fvARB;
1072
 
 
1073
 
   vfmt->Rectf = _mesa_noop_Rectf;
1074
 
 
1075
 
   vfmt->DrawArrays = _mesa_noop_DrawArrays;
1076
 
   vfmt->DrawElements = _mesa_noop_DrawElements;
1077
 
   vfmt->DrawRangeElements = _mesa_noop_DrawRangeElements;
1078
 
   vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
1079
 
   vfmt->DrawElementsBaseVertex = _mesa_noop_DrawElementsBaseVertex;
1080
 
   vfmt->DrawRangeElementsBaseVertex = _mesa_noop_DrawRangeElementsBaseVertex;
1081
 
   vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
1082
 
}
1083
 
 
1084
 
 
1085
 
#endif /* FEATURE_beginend */