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