src/mesa/shader/arbprogram.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.2
   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  * \file arbprogram.c
  27  * ARB_vertex/fragment_program state management functions.
  28  * \author Brian Paul
  29  */
  30
  31
  32 #include "glheader.h"
  33 #include "arbprogram.h"
  34 #include "arbprogparse.h"
  35 #include "context.h"
  36 #include "imports.h"
  37 #include "macros.h"
  38 #include "mtypes.h"
  39 #include "program.h"
  40
  41
  42 void GLAPIENTRY
  43 _mesa_EnableVertexAttribArrayARB(GLuint index)
  44 {
  45    GET_CURRENT_CONTEXT(ctx);
  46    ASSERT_OUTSIDE_BEGIN_END(ctx);
  47
  48    if (index >= ctx->Const.VertexProgram.MaxAttribs) {
  49       _mesa_error(ctx, GL_INVALID_VALUE,
  50                   "glEnableVertexAttribArrayARB(index)");
  51       return;
  52    }
  53
  54    FLUSH_VERTICES(ctx, _NEW_ARRAY);
  55    ctx->Array.ArrayObj->VertexAttrib[index].Enabled = GL_TRUE;
  56    ctx->Array.ArrayObj->_Enabled |= _NEW_ARRAY_ATTRIB(index);
  57    ctx->Array.NewState |= _NEW_ARRAY_ATTRIB(index);
  58 }
  59
  60
  61 void GLAPIENTRY
  62 _mesa_DisableVertexAttribArrayARB(GLuint index)
  63 {
  64    GET_CURRENT_CONTEXT(ctx);
  65    ASSERT_OUTSIDE_BEGIN_END(ctx);
  66
  67    if (index >= ctx->Const.VertexProgram.MaxAttribs) {
  68       _mesa_error(ctx, GL_INVALID_VALUE,
  69                   "glEnableVertexAttribArrayARB(index)");
  70       return;
  71    }
  72
  73    FLUSH_VERTICES(ctx, _NEW_ARRAY);
  74    ctx->Array.ArrayObj->VertexAttrib[index].Enabled = GL_FALSE;
  75    ctx->Array.ArrayObj->_Enabled &= ~_NEW_ARRAY_ATTRIB(index);
  76    ctx->Array.NewState |= _NEW_ARRAY_ATTRIB(index);
  77 }
  78
  79
  80 void GLAPIENTRY
  81 _mesa_GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params)
  82 {
  83    GLfloat fparams[4];
  84    GET_CURRENT_CONTEXT(ctx);
  85    ASSERT_OUTSIDE_BEGIN_END(ctx);
  86
  87    _mesa_GetVertexAttribfvARB(index, pname, fparams);
  88    if (ctx->ErrorValue == GL_NO_ERROR) {
  89       if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
  90          COPY_4V(params, fparams);
  91       }
  92       else {
  93          params[0] = fparams[0];
  94       }
  95    }
  96 }
  97
  98
  99 void GLAPIENTRY
 100 _mesa_GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params)
 101 {
 102    GET_CURRENT_CONTEXT(ctx);
 103    ASSERT_OUTSIDE_BEGIN_END(ctx);
 104
 105    if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) {
 106       _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribfvARB(index)");
 107       return;
 108    }
 109
 110    switch (pname) {
 111       case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
 112          params[0] = (GLfloat) ctx->Array.ArrayObj->VertexAttrib[index].Enabled;
 113          break;
 114       case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
 115          params[0] = (GLfloat) ctx->Array.ArrayObj->VertexAttrib[index].Size;
 116          break;
 117       case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
 118          params[0] = (GLfloat) ctx->Array.ArrayObj->VertexAttrib[index].Stride;
 119          break;
 120       case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
 121          params[0] = (GLfloat) ctx->Array.ArrayObj->VertexAttrib[index].Type;
 122          break;
 123       case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
 124          params[0] = ctx->Array.ArrayObj->VertexAttrib[index].Normalized;
 125          break;
 126       case GL_CURRENT_VERTEX_ATTRIB_ARB:
 127          if (index == 0) {
 128             _mesa_error(ctx, GL_INVALID_OPERATION,
 129                         "glGetVertexAttribfvARB(index==0)");
 130             return;
 131          }
 132          FLUSH_CURRENT(ctx, 0);
 133          COPY_4V(params, ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index]);
 134          break;
 135       case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB:
 136          if (!ctx->Extensions.ARB_vertex_buffer_object) {
 137             _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribfvARB(pname)");
 138             return;
 139          }
 140          params[0] = (GLfloat) ctx->Array.ArrayObj->VertexAttrib[index].BufferObj->Name;
 141          break;
 142       default:
 143          _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribfvARB(pname)");
 144          return;
 145    }
 146 }
 147
 148
 149 void GLAPIENTRY
 150 _mesa_GetVertexAttribivARB(GLuint index, GLenum pname, GLint *params)
 151 {
 152    GLfloat fparams[4];
 153    GET_CURRENT_CONTEXT(ctx);
 154    ASSERT_OUTSIDE_BEGIN_END(ctx);
 155
 156    _mesa_GetVertexAttribfvARB(index, pname, fparams);
 157    if (ctx->ErrorValue == GL_NO_ERROR) {
 158       if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
 159          COPY_4V_CAST(params, fparams, GLint);  /* float to int */
 160       }
 161       else {
 162          params[0] = (GLint) fparams[0];
 163       }
 164    }
 165 }
 166
 167
 168 void GLAPIENTRY
 169 _mesa_GetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer)
 170 {
 171    GET_CURRENT_CONTEXT(ctx);
 172    ASSERT_OUTSIDE_BEGIN_END(ctx);
 173
 174    if (index >= ctx->Const.VertexProgram.MaxAttribs) {
 175       _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribPointerARB(index)");
 176       return;
 177    }
 178
 179    if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB) {
 180       _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribPointerARB(pname)");
 181       return;
 182    }
 183
 184    *pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[index].Ptr;
 185 }
 186
 187
 188 /**
 189  * Determine if id names a vertex or fragment program.
 190  * \note Not compiled into display lists.
 191  * \note Called from both glIsProgramNV and glIsProgramARB.
 192  * \param id is the program identifier
 193  * \return GL_TRUE if id is a program, else GL_FALSE.
 194  */
 195 GLboolean GLAPIENTRY
 196 _mesa_IsProgramARB(GLuint id)
 197 {
 198    GET_CURRENT_CONTEXT(ctx);
 199    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 200
 201    if (id == 0)
 202       return GL_FALSE;
 203
 204    if (_mesa_lookup_program(ctx, id))
 205       return GL_TRUE;
 206    else
 207       return GL_FALSE;
 208 }
 209
 210
 211 void GLAPIENTRY
 212 _mesa_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
 213                        const GLvoid *string)
 214 {
 215    GET_CURRENT_CONTEXT(ctx);
 216    ASSERT_OUTSIDE_BEGIN_END(ctx);
 217
 218    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 219
 220    if (format != GL_PROGRAM_FORMAT_ASCII_ARB) {
 221       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)");
 222       return;
 223    }
 224
 225    if (target == GL_VERTEX_PROGRAM_ARB
 226        && ctx->Extensions.ARB_vertex_program) {
 227       struct gl_vertex_program *prog = ctx->VertexProgram.Current;
 228       _mesa_parse_arb_vertex_program(ctx, target, string, len, prog);
 229
 230       if (ctx->Driver.ProgramStringNotify)
 231          ctx->Driver.ProgramStringNotify( ctx, target, &prog->Base );
 232    }
 233    else if (target == GL_FRAGMENT_PROGRAM_ARB
 234             && ctx->Extensions.ARB_fragment_program) {
 235       struct gl_fragment_program *prog = ctx->FragmentProgram.Current;
 236       _mesa_parse_arb_fragment_program(ctx, target, string, len, prog);
 237
 238       if (ctx->Driver.ProgramStringNotify)
 239          ctx->Driver.ProgramStringNotify( ctx, target, &prog->Base );
 240    }
 241    else {
 242       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(target)");
 243       return;
 244    }
 245 }
 246
 247
 248 void GLAPIENTRY
 249 _mesa_ProgramEnvParameter4dARB(GLenum target, GLuint index,
 250                                GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 251 {
 252    _mesa_ProgramEnvParameter4fARB(target, index, (GLfloat) x, (GLfloat) y,
 253                                   (GLfloat) z, (GLfloat) w);
 254 }
 255
 256
 257 void GLAPIENTRY
 258 _mesa_ProgramEnvParameter4dvARB(GLenum target, GLuint index,
 259                                 const GLdouble *params)
 260 {
 261    _mesa_ProgramEnvParameter4fARB(target, index, (GLfloat) params[0],
 262                                   (GLfloat) params[1], (GLfloat) params[2],
 263                                   (GLfloat) params[3]);
 264 }
 265
 266
 267 void GLAPIENTRY
 268 _mesa_ProgramEnvParameter4fARB(GLenum target, GLuint index,
 269                                GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 270 {
 271    GET_CURRENT_CONTEXT(ctx);
 272    ASSERT_OUTSIDE_BEGIN_END(ctx);
 273
 274    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 275
 276    if (target == GL_FRAGMENT_PROGRAM_ARB
 277        && ctx->Extensions.ARB_fragment_program) {
 278       if (index >= ctx->Const.FragmentProgram.MaxEnvParams) {
 279          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameter(index)");
 280          return;
 281       }
 282       ASSIGN_4V(ctx->FragmentProgram.Parameters[index], x, y, z, w);
 283    }
 284    else if (target == GL_VERTEX_PROGRAM_ARB
 285        && ctx->Extensions.ARB_vertex_program) {
 286       if (index >= ctx->Const.VertexProgram.MaxEnvParams) {
 287          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameter(index)");
 288          return;
 289       }
 290       ASSIGN_4V(ctx->VertexProgram.Parameters[index], x, y, z, w);
 291    }
 292    else {
 293       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramEnvParameter(target)");
 294       return;
 295    }
 296 }
 297
 298
 299 void GLAPIENTRY
 300 _mesa_ProgramEnvParameter4fvARB(GLenum target, GLuint index,
 301                                    const GLfloat *params)
 302 {
 303    _mesa_ProgramEnvParameter4fARB(target, index, params[0], params[1],
 304                                   params[2], params[3]);
 305 }
 306
 307
 308 void GLAPIENTRY
 309 _mesa_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
 310                                  const GLfloat *params)
 311 {
 312    GET_CURRENT_CONTEXT(ctx);
 313    unsigned i;
 314    GLfloat * dest;
 315    ASSERT_OUTSIDE_BEGIN_END(ctx);
 316
 317    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 318
 319    if (count <= 0) {
 320       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameters4fv(count)");
 321    }
 322
 323    if (target == GL_FRAGMENT_PROGRAM_ARB
 324        && ctx->Extensions.ARB_fragment_program) {
 325       if ((index + count) > ctx->Const.FragmentProgram.MaxEnvParams) {
 326          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameters4fv(index + count)");
 327          return;
 328       }
 329       dest = ctx->FragmentProgram.Parameters[index];
 330    }
 331    else if (target == GL_VERTEX_PROGRAM_ARB
 332        && ctx->Extensions.ARB_vertex_program) {
 333       if ((index + count) > ctx->Const.VertexProgram.MaxEnvParams) {
 334          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameters4fv(index + count)");
 335          return;
 336       }
 337       dest = ctx->VertexProgram.Parameters[index];
 338    }
 339    else {
 340       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramEnvParameters4fv(target)");
 341       return;
 342    }
 343
 344    for ( i = 0 ; i < count ; i++ ) {
 345       COPY_4V(dest, params);
 346       params += 4;
 347       dest += 4;
 348    }
 349 }
 350
 351
 352 void GLAPIENTRY
 353 _mesa_GetProgramEnvParameterdvARB(GLenum target, GLuint index,
 354                                   GLdouble *params)
 355 {
 356    GET_CURRENT_CONTEXT(ctx);
 357    GLfloat fparams[4];
 358
 359    _mesa_GetProgramEnvParameterfvARB(target, index, fparams);
 360    if (ctx->ErrorValue == GL_NO_ERROR) {
 361       params[0] = fparams[0];
 362       params[1] = fparams[1];
 363       params[2] = fparams[2];
 364       params[3] = fparams[3];
 365    }
 366 }
 367
 368
 369 void GLAPIENTRY
 370 _mesa_GetProgramEnvParameterfvARB(GLenum target, GLuint index,
 371                                   GLfloat *params)
 372 {
 373    GET_CURRENT_CONTEXT(ctx);
 374
 375    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 376
 377    if (!ctx->_CurrentProgram)
 378       ASSERT_OUTSIDE_BEGIN_END(ctx);
 379
 380    if (target == GL_FRAGMENT_PROGRAM_ARB
 381        && ctx->Extensions.ARB_fragment_program) {
 382       if (index >= ctx->Const.FragmentProgram.MaxEnvParams) {
 383          _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramEnvParameter(index)");
 384          return;
 385       }
 386       COPY_4V(params, ctx->FragmentProgram.Parameters[index]);
 387    }
 388    else if (target == GL_VERTEX_PROGRAM_ARB
 389        && ctx->Extensions.ARB_vertex_program) {
 390       if (index >= ctx->Const.VertexProgram.MaxEnvParams) {
 391          _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramEnvParameter(index)");
 392          return;
 393       }
 394       COPY_4V(params, ctx->VertexProgram.Parameters[index]);
 395    }
 396    else {
 397       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramEnvParameter(target)");
 398       return;
 399    }
 400 }
 401
 402
 403 /**
 404  * Note, this function is also used by the GL_NV_fragment_program extension.
 405  */
 406 void GLAPIENTRY
 407 _mesa_ProgramLocalParameter4fARB(GLenum target, GLuint index,
 408                                  GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 409 {
 410    GET_CURRENT_CONTEXT(ctx);
 411    struct gl_program *prog;
 412    ASSERT_OUTSIDE_BEGIN_END(ctx);
 413
 414    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 415
 416    if ((target == GL_FRAGMENT_PROGRAM_NV
 417         && ctx->Extensions.NV_fragment_program) ||
 418        (target == GL_FRAGMENT_PROGRAM_ARB
 419         && ctx->Extensions.ARB_fragment_program)) {
 420       if (index >= ctx->Const.FragmentProgram.MaxLocalParams) {
 421          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameterARB");
 422          return;
 423       }
 424       prog = &(ctx->FragmentProgram.Current->Base);
 425    }
 426    else if (target == GL_VERTEX_PROGRAM_ARB
 427             && ctx->Extensions.ARB_vertex_program) {
 428       if (index >= ctx->Const.VertexProgram.MaxLocalParams) {
 429          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameterARB");
 430          return;
 431       }
 432       prog = &(ctx->VertexProgram.Current->Base);
 433    }
 434    else {
 435       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramLocalParameterARB");
 436       return;
 437    }
 438
 439    ASSERT(index < MAX_PROGRAM_LOCAL_PARAMS);
 440    prog->LocalParams[index][0] = x;
 441    prog->LocalParams[index][1] = y;
 442    prog->LocalParams[index][2] = z;
 443    prog->LocalParams[index][3] = w;
 444 }
 445
 446
 447 /**
 448  * Note, this function is also used by the GL_NV_fragment_program extension.
 449  */
 450 void GLAPIENTRY
 451 _mesa_ProgramLocalParameter4fvARB(GLenum target, GLuint index,
 452                                   const GLfloat *params)
 453 {
 454    _mesa_ProgramLocalParameter4fARB(target, index, params[0], params[1],
 455                                     params[2], params[3]);
 456 }
 457
 458
 459 void GLAPIENTRY
 460 _mesa_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
 461                                    const GLfloat *params)
 462 {
 463    GET_CURRENT_CONTEXT(ctx);
 464    struct gl_program *prog;
 465    unsigned i;
 466    ASSERT_OUTSIDE_BEGIN_END(ctx);
 467
 468    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 469
 470    if (count <= 0) {
 471       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameters4fv(count)");
 472    }
 473
 474    if (target == GL_FRAGMENT_PROGRAM_ARB
 475        && ctx->Extensions.ARB_fragment_program) {
 476       if ((index + count) > ctx->Const.FragmentProgram.MaxLocalParams) {
 477          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameters4fvEXT(index + count)");
 478          return;
 479       }
 480       prog = &(ctx->FragmentProgram.Current->Base);
 481    }
 482    else if (target == GL_VERTEX_PROGRAM_ARB
 483             && ctx->Extensions.ARB_vertex_program) {
 484       if ((index + count) > ctx->Const.VertexProgram.MaxLocalParams) {
 485          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameters4fvEXT(index + count)");
 486          return;
 487       }
 488       prog = &(ctx->VertexProgram.Current->Base);
 489    }
 490    else {
 491       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramLocalParameters4fvEXT(target)");
 492       return;
 493    }
 494
 495    for (i = 0; i < count; i++) {
 496       ASSERT((index + i) < MAX_PROGRAM_LOCAL_PARAMS);
 497       COPY_4V(prog->LocalParams[index + i], params);
 498       params += 4;
 499    }
 500 }
 501
 502
 503 /**
 504  * Note, this function is also used by the GL_NV_fragment_program extension.
 505  */
 506 void GLAPIENTRY
 507 _mesa_ProgramLocalParameter4dARB(GLenum target, GLuint index,
 508                                  GLdouble x, GLdouble y,
 509                                  GLdouble z, GLdouble w)
 510 {
 511    _mesa_ProgramLocalParameter4fARB(target, index, (GLfloat) x, (GLfloat) y,
 512                                     (GLfloat) z, (GLfloat) w);
 513 }
 514
 515
 516 /**
 517  * Note, this function is also used by the GL_NV_fragment_program extension.
 518  */
 519 void GLAPIENTRY
 520 _mesa_ProgramLocalParameter4dvARB(GLenum target, GLuint index,
 521                                   const GLdouble *params)
 522 {
 523    _mesa_ProgramLocalParameter4fARB(target, index,
 524                                     (GLfloat) params[0], (GLfloat) params[1],
 525                                     (GLfloat) params[2], (GLfloat) params[3]);
 526 }
 527
 528
 529 /**
 530  * Note, this function is also used by the GL_NV_fragment_program extension.
 531  */
 532 void GLAPIENTRY
 533 _mesa_GetProgramLocalParameterfvARB(GLenum target, GLuint index,
 534                                     GLfloat *params)
 535 {
 536    const struct gl_program *prog;
 537    GLuint maxParams;
 538    GET_CURRENT_CONTEXT(ctx);
 539    ASSERT_OUTSIDE_BEGIN_END(ctx);
 540
 541    if (target == GL_VERTEX_PROGRAM_ARB
 542        && ctx->Extensions.ARB_vertex_program) {
 543       prog = &(ctx->VertexProgram.Current->Base);
 544       maxParams = ctx->Const.VertexProgram.MaxLocalParams;
 545    }
 546    else if (target == GL_FRAGMENT_PROGRAM_ARB
 547             && ctx->Extensions.ARB_fragment_program) {
 548       prog = &(ctx->FragmentProgram.Current->Base);
 549       maxParams = ctx->Const.FragmentProgram.MaxLocalParams;
 550    }
 551    else if (target == GL_FRAGMENT_PROGRAM_NV
 552             && ctx->Extensions.NV_fragment_program) {
 553       prog = &(ctx->FragmentProgram.Current->Base);
 554       maxParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
 555    }
 556    else {
 557       _mesa_error(ctx, GL_INVALID_ENUM,
 558                   "glGetProgramLocalParameterARB(target)");
 559       return;
 560    }
 561
 562    if (index >= maxParams) {
 563       _mesa_error(ctx, GL_INVALID_VALUE,
 564                   "glGetProgramLocalParameterARB(index)");
 565       return;
 566    }
 567
 568    ASSERT(prog);
 569    ASSERT(index < MAX_PROGRAM_LOCAL_PARAMS);
 570    COPY_4V(params, prog->LocalParams[index]);
 571 }
 572
 573
 574 /**
 575  * Note, this function is also used by the GL_NV_fragment_program extension.
 576  */
 577 void GLAPIENTRY
 578 _mesa_GetProgramLocalParameterdvARB(GLenum target, GLuint index,
 579                                     GLdouble *params)
 580 {
 581    GET_CURRENT_CONTEXT(ctx);
 582    GLfloat floatParams[4];
 583    _mesa_GetProgramLocalParameterfvARB(target, index, floatParams);
 584    if (ctx->ErrorValue == GL_NO_ERROR) {
 585       COPY_4V(params, floatParams);
 586    }
 587 }
 588
 589
 590 void GLAPIENTRY
 591 _mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params)
 592 {
 593    const struct gl_program_constants *limits;
 594    struct gl_program *prog;
 595    GET_CURRENT_CONTEXT(ctx);
 596
 597    if (!ctx->_CurrentProgram)
 598       ASSERT_OUTSIDE_BEGIN_END(ctx);
 599
 600    if (target == GL_VERTEX_PROGRAM_ARB
 601        && ctx->Extensions.ARB_vertex_program) {
 602       prog = &(ctx->VertexProgram.Current->Base);
 603       limits = &ctx->Const.VertexProgram;
 604    }
 605    else if (target == GL_FRAGMENT_PROGRAM_ARB
 606             && ctx->Extensions.ARB_fragment_program) {
 607       prog = &(ctx->FragmentProgram.Current->Base);
 608       limits = &ctx->Const.FragmentProgram;
 609    }
 610    else {
 611       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
 612       return;
 613    }
 614
 615    ASSERT(prog);
 616    ASSERT(limits);
 617
 618    /* Queries supported for both vertex and fragment programs */
 619    switch (pname) {
 620       case GL_PROGRAM_LENGTH_ARB:
 621          *params
 622             = prog->String ? (GLint) _mesa_strlen((char *) prog->String) : 0;
 623          return;
 624       case GL_PROGRAM_FORMAT_ARB:
 625          *params = prog->Format;
 626          return;
 627       case GL_PROGRAM_BINDING_ARB:
 628          *params = prog->Id;
 629          return;
 630       case GL_PROGRAM_INSTRUCTIONS_ARB:
 631          *params = prog->NumInstructions;
 632          return;
 633       case GL_MAX_PROGRAM_INSTRUCTIONS_ARB:
 634          *params = limits->MaxInstructions;
 635          return;
 636       case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
 637          *params = prog->NumNativeInstructions;
 638          return;
 639       case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
 640          *params = limits->MaxNativeInstructions;
 641          return;
 642       case GL_PROGRAM_TEMPORARIES_ARB:
 643          *params = prog->NumTemporaries;
 644          return;
 645       case GL_MAX_PROGRAM_TEMPORARIES_ARB:
 646          *params = limits->MaxTemps;
 647          return;
 648       case GL_PROGRAM_NATIVE_TEMPORARIES_ARB:
 649          *params = prog->NumNativeTemporaries;
 650          return;
 651       case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB:
 652          *params = limits->MaxNativeTemps;
 653          return;
 654       case GL_PROGRAM_PARAMETERS_ARB:
 655          *params = prog->NumParameters;
 656          return;
 657       case GL_MAX_PROGRAM_PARAMETERS_ARB:
 658          *params = limits->MaxParameters;
 659          return;
 660       case GL_PROGRAM_NATIVE_PARAMETERS_ARB:
 661          *params = prog->NumNativeParameters;
 662          return;
 663       case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB:
 664          *params = limits->MaxNativeParameters;
 665          return;
 666       case GL_PROGRAM_ATTRIBS_ARB:
 667          *params = prog->NumAttributes;
 668          return;
 669       case GL_MAX_PROGRAM_ATTRIBS_ARB:
 670          *params = limits->MaxAttribs;
 671          return;
 672       case GL_PROGRAM_NATIVE_ATTRIBS_ARB:
 673          *params = prog->NumNativeAttributes;
 674          return;
 675       case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB:
 676          *params = limits->MaxNativeAttribs;
 677          return;
 678       case GL_PROGRAM_ADDRESS_REGISTERS_ARB:
 679          *params = prog->NumAddressRegs;
 680          return;
 681       case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB:
 682          *params = limits->MaxAddressRegs;
 683          return;
 684       case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
 685          *params = prog->NumNativeAddressRegs;
 686          return;
 687       case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
 688          *params = limits->MaxNativeAddressRegs;
 689          return;
 690       case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB:
 691          *params = limits->MaxLocalParams;
 692          return;
 693       case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB:
 694          *params = limits->MaxEnvParams;
 695          return;
 696       case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB:
 697          /*
 698           * XXX we may not really need a driver callback here.
 699           * If the number of native instructions, registers, etc. used
 700           * are all below the maximums, we could return true.
 701           * The spec says that even if this query returns true, there's
 702           * no guarantee that the program will run in hardware.
 703           */
 704          if (ctx->Driver.IsProgramNative)
 705             *params = ctx->Driver.IsProgramNative( ctx, target, prog );
 706          else
 707             *params = GL_TRUE;
 708          return;
 709       default:
 710          /* continue with fragment-program only queries below */
 711          break;
 712    }
 713
 714    /*
 715     * The following apply to fragment programs only (at this time)
 716     */
 717    if (target == GL_FRAGMENT_PROGRAM_ARB) {
 718       const struct gl_fragment_program *fp = ctx->FragmentProgram.Current;
 719       switch (pname) {
 720          case GL_PROGRAM_ALU_INSTRUCTIONS_ARB:
 721             *params = fp->NumNativeAluInstructions;
 722             return;
 723          case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
 724             *params = fp->NumAluInstructions;
 725             return;
 726          case GL_PROGRAM_TEX_INSTRUCTIONS_ARB:
 727             *params = fp->NumTexInstructions;
 728             return;
 729          case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
 730             *params = fp->NumNativeTexInstructions;
 731             return;
 732          case GL_PROGRAM_TEX_INDIRECTIONS_ARB:
 733             *params = fp->NumTexIndirections;
 734             return;
 735          case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
 736             *params = fp->NumNativeTexIndirections;
 737             return;
 738          case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB:
 739             *params = limits->MaxAluInstructions;
 740             return;
 741          case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
 742             *params = limits->MaxNativeAluInstructions;
 743             return;
 744          case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB:
 745             *params = limits->MaxTexInstructions;
 746             return;
 747          case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
 748             *params = limits->MaxNativeTexInstructions;
 749             return;
 750          case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB:
 751             *params = limits->MaxTexIndirections;
 752             return;
 753          case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
 754             *params = limits->MaxNativeTexIndirections;
 755             return;
 756          default:
 757             _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(pname)");
 758             return;
 759       }
 760    }
 761 }
 762
 763
 764 void GLAPIENTRY
 765 _mesa_GetProgramStringARB(GLenum target, GLenum pname, GLvoid *string)
 766 {
 767    const struct gl_program *prog;
 768    GET_CURRENT_CONTEXT(ctx);
 769
 770    if (!ctx->_CurrentProgram)
 771       ASSERT_OUTSIDE_BEGIN_END(ctx);
 772
 773    if (target == GL_VERTEX_PROGRAM_ARB) {
 774       prog = &(ctx->VertexProgram.Current->Base);
 775    }
 776    else if (target == GL_FRAGMENT_PROGRAM_ARB) {
 777       prog = &(ctx->FragmentProgram.Current->Base);
 778    }
 779    else {
 780       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringARB(target)");
 781       return;
 782    }
 783
 784    ASSERT(prog);
 785
 786    if (pname != GL_PROGRAM_STRING_ARB) {
 787       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringARB(pname)");
 788       return;
 789    }
 790
 791    _mesa_memcpy(string, prog->String, _mesa_strlen((char *) prog->String));
 792 }