src/mesa/main/arbprogram.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * 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 "main/glheader.h"
  33 #include "main/context.h"
  34 #include "main/hash.h"
  35 #include "main/imports.h"
  36 #include "main/macros.h"
  37 #include "main/mtypes.h"
  38 #include "main/arbprogram.h"
  39 #include "main/shaderapi.h"
  40 #include "program/arbprogparse.h"
  41 #include "program/program.h"
  42 #include "program/prog_print.h"
  43
  44 /**
  45  * Bind a program (make it current)
  46  * \note Called from the GL API dispatcher by both glBindProgramNV
  47  * and glBindProgramARB.
  48  */
  49 void GLAPIENTRY
  50 _mesa_BindProgramARB(GLenum target, GLuint id)
  51 {
  52    struct gl_program *curProg, *newProg;
  53    GET_CURRENT_CONTEXT(ctx);
  54
  55    /* Error-check target and get curProg */
  56    if (target == GL_VERTEX_PROGRAM_ARB && ctx->Extensions.ARB_vertex_program) {
  57       curProg = ctx->VertexProgram.Current;
  58    }
  59    else if (target == GL_FRAGMENT_PROGRAM_ARB
  60             && ctx->Extensions.ARB_fragment_program) {
  61       curProg = ctx->FragmentProgram.Current;
  62    }
  63    else {
  64       _mesa_error(ctx, GL_INVALID_ENUM, "glBindProgramARB(target)");
  65       return;
  66    }
  67
  68    /*
  69     * Get pointer to new program to bind.
  70     * NOTE: binding to a non-existant program is not an error.
  71     * That's supposed to be caught in glBegin.
  72     */
  73    if (id == 0) {
  74       /* Bind a default program */
  75       newProg = NULL;
  76       if (target == GL_VERTEX_PROGRAM_ARB)
  77          newProg = ctx->Shared->DefaultVertexProgram;
  78       else
  79          newProg = ctx->Shared->DefaultFragmentProgram;
  80    }
  81    else {
  82       /* Bind a user program */
  83       newProg = _mesa_lookup_program(ctx, id);
  84       if (!newProg || newProg == &_mesa_DummyProgram) {
  85          /* allocate a new program now */
  86          newProg = ctx->Driver.NewProgram(ctx, target, id, true);
  87          if (!newProg) {
  88             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindProgramARB");
  89             return;
  90          }
  91          _mesa_HashInsert(ctx->Shared->Programs, id, newProg);
  92       }
  93       else if (newProg->Target != target) {
  94          _mesa_error(ctx, GL_INVALID_OPERATION,
  95                      "glBindProgramARB(target mismatch)");
  96          return;
  97       }
  98    }
  99
 100    /** All error checking is complete now **/
 101
 102    if (curProg->Id == id) {
 103       /* binding same program - no change */
 104       return;
 105    }
 106
 107    /* signal new program (and its new constants) */
 108    FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 109
 110    /* bind newProg */
 111    if (target == GL_VERTEX_PROGRAM_ARB) {
 112       _mesa_reference_program(ctx, &ctx->VertexProgram.Current, newProg);
 113    }
 114    else if (target == GL_FRAGMENT_PROGRAM_ARB) {
 115       _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, newProg);
 116    }
 117
 118    /* Never null pointers */
 119    assert(ctx->VertexProgram.Current);
 120    assert(ctx->FragmentProgram.Current);
 121 }
 122
 123
 124 /**
 125  * Delete a list of programs.
 126  * \note Not compiled into display lists.
 127  * \note Called by both glDeleteProgramsNV and glDeleteProgramsARB.
 128  */
 129 void GLAPIENTRY
 130 _mesa_DeleteProgramsARB(GLsizei n, const GLuint *ids)
 131 {
 132    GLint i;
 133    GET_CURRENT_CONTEXT(ctx);
 134
 135    FLUSH_VERTICES(ctx, 0);
 136
 137    if (n < 0) {
 138       _mesa_error( ctx, GL_INVALID_VALUE, "glDeleteProgramsNV" );
 139       return;
 140    }
 141
 142    for (i = 0; i < n; i++) {
 143       if (ids[i] != 0) {
 144          struct gl_program *prog = _mesa_lookup_program(ctx, ids[i]);
 145          if (prog == &_mesa_DummyProgram) {
 146             _mesa_HashRemove(ctx->Shared->Programs, ids[i]);
 147          }
 148          else if (prog) {
 149             /* Unbind program if necessary */
 150             switch (prog->Target) {
 151             case GL_VERTEX_PROGRAM_ARB:
 152                if (ctx->VertexProgram.Current &&
 153                    ctx->VertexProgram.Current->Id == ids[i]) {
 154                   /* unbind this currently bound program */
 155                   _mesa_BindProgramARB(prog->Target, 0);
 156                }
 157                break;
 158             case GL_FRAGMENT_PROGRAM_ARB:
 159                if (ctx->FragmentProgram.Current &&
 160                    ctx->FragmentProgram.Current->Id == ids[i]) {
 161                   /* unbind this currently bound program */
 162                   _mesa_BindProgramARB(prog->Target, 0);
 163                }
 164                break;
 165             default:
 166                _mesa_problem(ctx, "bad target in glDeleteProgramsNV");
 167                return;
 168             }
 169             /* The ID is immediately available for re-use now */
 170             _mesa_HashRemove(ctx->Shared->Programs, ids[i]);
 171             _mesa_reference_program(ctx, &prog, NULL);
 172          }
 173       }
 174    }
 175 }
 176
 177
 178 /**
 179  * Generate a list of new program identifiers.
 180  * \note Not compiled into display lists.
 181  * \note Called by both glGenProgramsNV and glGenProgramsARB.
 182  */
 183 void GLAPIENTRY
 184 _mesa_GenProgramsARB(GLsizei n, GLuint *ids)
 185 {
 186    GLuint first;
 187    GLuint i;
 188    GET_CURRENT_CONTEXT(ctx);
 189
 190    if (n < 0) {
 191       _mesa_error(ctx, GL_INVALID_VALUE, "glGenPrograms");
 192       return;
 193    }
 194
 195    if (!ids)
 196       return;
 197
 198    _mesa_HashLockMutex(ctx->Shared->Programs);
 199
 200    first = _mesa_HashFindFreeKeyBlock(ctx->Shared->Programs, n);
 201
 202    /* Insert pointer to dummy program as placeholder */
 203    for (i = 0; i < (GLuint) n; i++) {
 204       _mesa_HashInsertLocked(ctx->Shared->Programs, first + i,
 205                              &_mesa_DummyProgram);
 206    }
 207
 208    _mesa_HashUnlockMutex(ctx->Shared->Programs);
 209
 210    /* Return the program names */
 211    for (i = 0; i < (GLuint) n; i++) {
 212       ids[i] = first + i;
 213    }
 214 }
 215
 216
 217 /**
 218  * Determine if id names a vertex or fragment program.
 219  * \note Not compiled into display lists.
 220  * \note Called from both glIsProgramNV and glIsProgramARB.
 221  * \param id is the program identifier
 222  * \return GL_TRUE if id is a program, else GL_FALSE.
 223  */
 224 GLboolean GLAPIENTRY
 225 _mesa_IsProgramARB(GLuint id)
 226 {
 227    struct gl_program *prog = NULL;
 228    GET_CURRENT_CONTEXT(ctx);
 229    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 230
 231    if (id == 0)
 232       return GL_FALSE;
 233
 234    prog = _mesa_lookup_program(ctx, id);
 235    if (prog && (prog != &_mesa_DummyProgram))
 236       return GL_TRUE;
 237    else
 238       return GL_FALSE;
 239 }
 240
 241 static GLboolean
 242 get_local_param_pointer(struct gl_context *ctx, const char *func,
 243                         GLenum target, GLuint index, GLfloat **param)
 244 {
 245    struct gl_program *prog;
 246    GLuint maxParams;
 247
 248    if (target == GL_VERTEX_PROGRAM_ARB
 249        && ctx->Extensions.ARB_vertex_program) {
 250       prog = ctx->VertexProgram.Current;
 251       maxParams = ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams;
 252    }
 253    else if (target == GL_FRAGMENT_PROGRAM_ARB
 254             && ctx->Extensions.ARB_fragment_program) {
 255       prog = ctx->FragmentProgram.Current;
 256       maxParams = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams;
 257    }
 258    else {
 259       _mesa_error(ctx, GL_INVALID_ENUM,
 260                   "%s(target)", func);
 261       return GL_FALSE;
 262    }
 263
 264    if (index >= maxParams) {
 265       _mesa_error(ctx, GL_INVALID_VALUE, "%s(index)", func);
 266       return GL_FALSE;
 267    }
 268
 269    if (!prog->arb.LocalParams) {
 270       prog->arb.LocalParams = rzalloc_array_size(prog, sizeof(float[4]),
 271                                              maxParams);
 272       if (!prog->arb.LocalParams)
 273          return GL_FALSE;
 274    }
 275
 276    *param = prog->arb.LocalParams[index];
 277    return GL_TRUE;
 278 }
 279
 280
 281 static GLboolean
 282 get_env_param_pointer(struct gl_context *ctx, const char *func,
 283                       GLenum target, GLuint index, GLfloat **param)
 284 {
 285    if (target == GL_FRAGMENT_PROGRAM_ARB
 286        && ctx->Extensions.ARB_fragment_program) {
 287       if (index >= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxEnvParams) {
 288          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index)", func);
 289          return GL_FALSE;
 290       }
 291       *param = ctx->FragmentProgram.Parameters[index];
 292       return GL_TRUE;
 293    }
 294    else if (target == GL_VERTEX_PROGRAM_ARB &&
 295             ctx->Extensions.ARB_vertex_program) {
 296       if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxEnvParams) {
 297          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index)", func);
 298          return GL_FALSE;
 299       }
 300       *param = ctx->VertexProgram.Parameters[index];
 301       return GL_TRUE;
 302    } else {
 303       _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", func);
 304       return GL_FALSE;
 305    }
 306 }
 307
 308 void GLAPIENTRY
 309 _mesa_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
 310                        const GLvoid *string)
 311 {
 312    struct gl_program *prog;
 313    bool failed;
 314    GET_CURRENT_CONTEXT(ctx);
 315
 316    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 317
 318    if (!ctx->Extensions.ARB_vertex_program
 319        && !ctx->Extensions.ARB_fragment_program) {
 320       _mesa_error(ctx, GL_INVALID_OPERATION, "glProgramStringARB()");
 321       return;
 322    }
 323
 324    if (format != GL_PROGRAM_FORMAT_ASCII_ARB) {
 325       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)");
 326       return;
 327    }
 328
 329    if (target == GL_VERTEX_PROGRAM_ARB && ctx->Extensions.ARB_vertex_program) {
 330       prog = ctx->VertexProgram.Current;
 331       _mesa_parse_arb_vertex_program(ctx, target, string, len, prog);
 332    }
 333    else if (target == GL_FRAGMENT_PROGRAM_ARB
 334             && ctx->Extensions.ARB_fragment_program) {
 335       prog = ctx->FragmentProgram.Current;
 336       _mesa_parse_arb_fragment_program(ctx, target, string, len, prog);
 337    }
 338    else {
 339       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(target)");
 340       return;
 341    }
 342
 343    failed = ctx->Program.ErrorPos != -1;
 344
 345    if (!failed) {
 346       /* finally, give the program to the driver for translation/checking */
 347       if (!ctx->Driver.ProgramStringNotify(ctx, target, prog)) {
 348          failed = true;
 349          _mesa_error(ctx, GL_INVALID_OPERATION,
 350                      "glProgramStringARB(rejected by driver");
 351       }
 352    }
 353
 354    if (ctx->_Shader->Flags & GLSL_DUMP) {
 355       const char *shader_type =
 356          target == GL_FRAGMENT_PROGRAM_ARB ? "fragment" : "vertex";
 357
 358       fprintf(stderr, "ARB_%s_program source for program %d:\n",
 359               shader_type, prog->Id);
 360       fprintf(stderr, "%s\n", (const char *) string);
 361
 362       if (failed) {
 363          fprintf(stderr, "ARB_%s_program %d failed to compile.\n",
 364                  shader_type, prog->Id);
 365       } else {
 366          fprintf(stderr, "Mesa IR for ARB_%s_program %d:\n",
 367                  shader_type, prog->Id);
 368          _mesa_print_program(prog);
 369          fprintf(stderr, "\n");
 370       }
 371       fflush(stderr);
 372    }
 373
 374    /* Capture vp-*.shader_test/fp-*.shader_test files. */
 375    const char *capture_path = _mesa_get_shader_capture_path();
 376    if (capture_path != NULL) {
 377       FILE *file;
 378       const char *shader_type =
 379          target == GL_FRAGMENT_PROGRAM_ARB ? "fragment" : "vertex";
 380       char *filename =
 381          ralloc_asprintf(NULL, "%s/%cp-%u.shader_test",
 382                          capture_path, shader_type[0], prog->Id);
 383
 384       file = fopen(filename, "w");
 385       if (file) {
 386          fprintf(file,
 387                  "[require]\nGL_ARB_%s_program\n\n[%s program]\n%s\n",
 388                  shader_type, shader_type, (const char *) string);
 389          fclose(file);
 390       } else {
 391          _mesa_warning(ctx, "Failed to open %s", filename);
 392       }
 393       ralloc_free(filename);
 394    }
 395 }
 396
 397
 398 /**
 399  * Set a program env parameter register.
 400  * \note Called from the GL API dispatcher.
 401  */
 402 void GLAPIENTRY
 403 _mesa_ProgramEnvParameter4dARB(GLenum target, GLuint index,
 404                                GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 405 {
 406    _mesa_ProgramEnvParameter4fARB(target, index, (GLfloat) x, (GLfloat) y,
 407                                   (GLfloat) z, (GLfloat) w);
 408 }
 409
 410
 411 /**
 412  * Set a program env parameter register.
 413  * \note Called from the GL API dispatcher.
 414  */
 415 void GLAPIENTRY
 416 _mesa_ProgramEnvParameter4dvARB(GLenum target, GLuint index,
 417                                 const GLdouble *params)
 418 {
 419    _mesa_ProgramEnvParameter4fARB(target, index, (GLfloat) params[0],
 420                                   (GLfloat) params[1], (GLfloat) params[2],
 421                                   (GLfloat) params[3]);
 422 }
 423
 424
 425 /**
 426  * Set a program env parameter register.
 427  * \note Called from the GL API dispatcher.
 428  */
 429 void GLAPIENTRY
 430 _mesa_ProgramEnvParameter4fARB(GLenum target, GLuint index,
 431                                GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 432 {
 433    GLfloat *param;
 434
 435    GET_CURRENT_CONTEXT(ctx);
 436
 437    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
 438
 439    if (get_env_param_pointer(ctx, "glProgramEnvParameter",
 440                              target, index, &param)) {
 441       ASSIGN_4V(param, x, y, z, w);
 442    }
 443 }
 444
 445
 446
 447 /**
 448  * Set a program env parameter register.
 449  * \note Called from the GL API dispatcher.
 450  */
 451 void GLAPIENTRY
 452 _mesa_ProgramEnvParameter4fvARB(GLenum target, GLuint index,
 453                                 const GLfloat *params)
 454 {
 455    GLfloat *param;
 456
 457    GET_CURRENT_CONTEXT(ctx);
 458
 459    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
 460
 461    if (get_env_param_pointer(ctx, "glProgramEnvParameter4fv",
 462                               target, index, &param)) {
 463       memcpy(param, params, 4 * sizeof(GLfloat));
 464    }
 465 }
 466
 467
 468 void GLAPIENTRY
 469 _mesa_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
 470                                  const GLfloat *params)
 471 {
 472    GET_CURRENT_CONTEXT(ctx);
 473    GLfloat * dest;
 474
 475    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
 476
 477    if (count <= 0) {
 478       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameters4fv(count)");
 479    }
 480
 481    if (target == GL_FRAGMENT_PROGRAM_ARB
 482        && ctx->Extensions.ARB_fragment_program) {
 483       if ((index + count) > ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxEnvParams) {
 484          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameters4fv(index + count)");
 485          return;
 486       }
 487       dest = ctx->FragmentProgram.Parameters[index];
 488    }
 489    else if (target == GL_VERTEX_PROGRAM_ARB
 490        && ctx->Extensions.ARB_vertex_program) {
 491       if ((index + count) > ctx->Const.Program[MESA_SHADER_VERTEX].MaxEnvParams) {
 492          _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameters4fv(index + count)");
 493          return;
 494       }
 495       dest = ctx->VertexProgram.Parameters[index];
 496    }
 497    else {
 498       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramEnvParameters4fv(target)");
 499       return;
 500    }
 501
 502    memcpy(dest, params, count * 4 * sizeof(GLfloat));
 503 }
 504
 505
 506 void GLAPIENTRY
 507 _mesa_GetProgramEnvParameterdvARB(GLenum target, GLuint index,
 508                                   GLdouble *params)
 509 {
 510    GET_CURRENT_CONTEXT(ctx);
 511    GLfloat *fparam;
 512
 513    if (get_env_param_pointer(ctx, "glGetProgramEnvParameterdv",
 514                              target, index, &fparam)) {
 515       COPY_4V(params, fparam);
 516    }
 517 }
 518
 519
 520 void GLAPIENTRY
 521 _mesa_GetProgramEnvParameterfvARB(GLenum target, GLuint index,
 522                                   GLfloat *params)
 523 {
 524    GLfloat *param;
 525
 526    GET_CURRENT_CONTEXT(ctx);
 527
 528    if (get_env_param_pointer(ctx, "glGetProgramEnvParameterfv",
 529                               target, index, &param)) {
 530       COPY_4V(params, param);
 531    }
 532 }
 533
 534
 535 void GLAPIENTRY
 536 _mesa_ProgramLocalParameter4fARB(GLenum target, GLuint index,
 537                                  GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 538 {
 539    GET_CURRENT_CONTEXT(ctx);
 540    GLfloat *param;
 541
 542    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
 543
 544    if (get_local_param_pointer(ctx, "glProgramLocalParameterARB",
 545                                target, index, &param)) {
 546       assert(index < MAX_PROGRAM_LOCAL_PARAMS);
 547       ASSIGN_4V(param, x, y, z, w);
 548    }
 549 }
 550
 551
 552 void GLAPIENTRY
 553 _mesa_ProgramLocalParameter4fvARB(GLenum target, GLuint index,
 554                                   const GLfloat *params)
 555 {
 556    _mesa_ProgramLocalParameter4fARB(target, index, params[0], params[1],
 557                                     params[2], params[3]);
 558 }
 559
 560
 561 void GLAPIENTRY
 562 _mesa_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
 563                                    const GLfloat *params)
 564 {
 565    GET_CURRENT_CONTEXT(ctx);
 566    GLfloat *dest;
 567
 568    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
 569
 570    if (count <= 0) {
 571       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameters4fv(count)");
 572    }
 573
 574    if (get_local_param_pointer(ctx, "glProgramLocalParameters4fvEXT",
 575                                target, index, &dest)) {
 576       GLuint maxParams = target == GL_FRAGMENT_PROGRAM_ARB ?
 577          ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams :
 578          ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams;
 579
 580       if ((index + count) > maxParams) {
 581          _mesa_error(ctx, GL_INVALID_VALUE,
 582                      "glProgramLocalParameters4fvEXT(index + count)");
 583          return;
 584       }
 585
 586       memcpy(dest, params, count * 4 * sizeof(GLfloat));
 587    }
 588 }
 589
 590
 591 void GLAPIENTRY
 592 _mesa_ProgramLocalParameter4dARB(GLenum target, GLuint index,
 593                                  GLdouble x, GLdouble y,
 594                                  GLdouble z, GLdouble w)
 595 {
 596    _mesa_ProgramLocalParameter4fARB(target, index, (GLfloat) x, (GLfloat) y,
 597                                     (GLfloat) z, (GLfloat) w);
 598 }
 599
 600
 601 void GLAPIENTRY
 602 _mesa_ProgramLocalParameter4dvARB(GLenum target, GLuint index,
 603                                   const GLdouble *params)
 604 {
 605    _mesa_ProgramLocalParameter4fARB(target, index,
 606                                     (GLfloat) params[0], (GLfloat) params[1],
 607                                     (GLfloat) params[2], (GLfloat) params[3]);
 608 }
 609
 610
 611 void GLAPIENTRY
 612 _mesa_GetProgramLocalParameterfvARB(GLenum target, GLuint index,
 613                                     GLfloat *params)
 614 {
 615    GLfloat *param;
 616    GET_CURRENT_CONTEXT(ctx);
 617
 618    if (get_local_param_pointer(ctx, "glProgramLocalParameters4fvEXT",
 619                                 target, index, &param)) {
 620       COPY_4V(params, param);
 621    }
 622 }
 623
 624
 625 void GLAPIENTRY
 626 _mesa_GetProgramLocalParameterdvARB(GLenum target, GLuint index,
 627                                     GLdouble *params)
 628 {
 629    GLfloat *param;
 630    GET_CURRENT_CONTEXT(ctx);
 631
 632    if (get_local_param_pointer(ctx, "glProgramLocalParameters4fvEXT",
 633                                 target, index, &param)) {
 634       COPY_4V(params, param);
 635    }
 636 }
 637
 638
 639 void GLAPIENTRY
 640 _mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params)
 641 {
 642    const struct gl_program_constants *limits;
 643    struct gl_program *prog;
 644    GET_CURRENT_CONTEXT(ctx);
 645
 646    if (target == GL_VERTEX_PROGRAM_ARB
 647        && ctx->Extensions.ARB_vertex_program) {
 648       prog = ctx->VertexProgram.Current;
 649       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
 650    }
 651    else if (target == GL_FRAGMENT_PROGRAM_ARB
 652             && ctx->Extensions.ARB_fragment_program) {
 653       prog = ctx->FragmentProgram.Current;
 654       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
 655    }
 656    else {
 657       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
 658       return;
 659    }
 660
 661    assert(prog);
 662    assert(limits);
 663
 664    /* Queries supported for both vertex and fragment programs */
 665    switch (pname) {
 666       case GL_PROGRAM_LENGTH_ARB:
 667          *params
 668             = prog->String ? (GLint) strlen((char *) prog->String) : 0;
 669          return;
 670       case GL_PROGRAM_FORMAT_ARB:
 671          *params = prog->Format;
 672          return;
 673       case GL_PROGRAM_BINDING_ARB:
 674          *params = prog->Id;
 675          return;
 676       case GL_PROGRAM_INSTRUCTIONS_ARB:
 677          *params = prog->arb.NumInstructions;
 678          return;
 679       case GL_MAX_PROGRAM_INSTRUCTIONS_ARB:
 680          *params = limits->MaxInstructions;
 681          return;
 682       case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
 683          *params = prog->arb.NumNativeInstructions;
 684          return;
 685       case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
 686          *params = limits->MaxNativeInstructions;
 687          return;
 688       case GL_PROGRAM_TEMPORARIES_ARB:
 689          *params = prog->arb.NumTemporaries;
 690          return;
 691       case GL_MAX_PROGRAM_TEMPORARIES_ARB:
 692          *params = limits->MaxTemps;
 693          return;
 694       case GL_PROGRAM_NATIVE_TEMPORARIES_ARB:
 695          *params = prog->arb.NumNativeTemporaries;
 696          return;
 697       case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB:
 698          *params = limits->MaxNativeTemps;
 699          return;
 700       case GL_PROGRAM_PARAMETERS_ARB:
 701          *params = prog->arb.NumParameters;
 702          return;
 703       case GL_MAX_PROGRAM_PARAMETERS_ARB:
 704          *params = limits->MaxParameters;
 705          return;
 706       case GL_PROGRAM_NATIVE_PARAMETERS_ARB:
 707          *params = prog->arb.NumNativeParameters;
 708          return;
 709       case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB:
 710          *params = limits->MaxNativeParameters;
 711          return;
 712       case GL_PROGRAM_ATTRIBS_ARB:
 713          *params = prog->arb.NumAttributes;
 714          return;
 715       case GL_MAX_PROGRAM_ATTRIBS_ARB:
 716          *params = limits->MaxAttribs;
 717          return;
 718       case GL_PROGRAM_NATIVE_ATTRIBS_ARB:
 719          *params = prog->arb.NumNativeAttributes;
 720          return;
 721       case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB:
 722          *params = limits->MaxNativeAttribs;
 723          return;
 724       case GL_PROGRAM_ADDRESS_REGISTERS_ARB:
 725          *params = prog->arb.NumAddressRegs;
 726          return;
 727       case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB:
 728          *params = limits->MaxAddressRegs;
 729          return;
 730       case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
 731          *params = prog->arb.NumNativeAddressRegs;
 732          return;
 733       case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
 734          *params = limits->MaxNativeAddressRegs;
 735          return;
 736       case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB:
 737          *params = limits->MaxLocalParams;
 738          return;
 739       case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB:
 740          *params = limits->MaxEnvParams;
 741          return;
 742       case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB:
 743          /*
 744           * XXX we may not really need a driver callback here.
 745           * If the number of native instructions, registers, etc. used
 746           * are all below the maximums, we could return true.
 747           * The spec says that even if this query returns true, there's
 748           * no guarantee that the program will run in hardware.
 749           */
 750          if (prog->Id == 0) {
 751             /* default/null program */
 752             *params = GL_FALSE;
 753          }
 754          else if (ctx->Driver.IsProgramNative) {
 755             /* ask the driver */
 756             *params = ctx->Driver.IsProgramNative( ctx, target, prog );
 757          }
 758          else {
 759             /* probably running in software */
 760             *params = GL_TRUE;
 761          }
 762          return;
 763       default:
 764          /* continue with fragment-program only queries below */
 765          break;
 766    }
 767
 768    /*
 769     * The following apply to fragment programs only (at this time)
 770     */
 771    if (target == GL_FRAGMENT_PROGRAM_ARB) {
 772       const struct gl_program *fp = ctx->FragmentProgram.Current;
 773       switch (pname) {
 774          case GL_PROGRAM_ALU_INSTRUCTIONS_ARB:
 775             *params = fp->arb.NumNativeAluInstructions;
 776             return;
 777          case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
 778             *params = fp->arb.NumAluInstructions;
 779             return;
 780          case GL_PROGRAM_TEX_INSTRUCTIONS_ARB:
 781             *params = fp->arb.NumTexInstructions;
 782             return;
 783          case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
 784             *params = fp->arb.NumNativeTexInstructions;
 785             return;
 786          case GL_PROGRAM_TEX_INDIRECTIONS_ARB:
 787             *params = fp->arb.NumTexIndirections;
 788             return;
 789          case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
 790             *params = fp->arb.NumNativeTexIndirections;
 791             return;
 792          case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB:
 793             *params = limits->MaxAluInstructions;
 794             return;
 795          case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
 796             *params = limits->MaxNativeAluInstructions;
 797             return;
 798          case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB:
 799             *params = limits->MaxTexInstructions;
 800             return;
 801          case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
 802             *params = limits->MaxNativeTexInstructions;
 803             return;
 804          case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB:
 805             *params = limits->MaxTexIndirections;
 806             return;
 807          case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
 808             *params = limits->MaxNativeTexIndirections;
 809             return;
 810          default:
 811             _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(pname)");
 812             return;
 813       }
 814    } else {
 815       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(pname)");
 816       return;
 817    }
 818 }
 819
 820
 821 void GLAPIENTRY
 822 _mesa_GetProgramStringARB(GLenum target, GLenum pname, GLvoid *string)
 823 {
 824    const struct gl_program *prog;
 825    char *dst = (char *) string;
 826    GET_CURRENT_CONTEXT(ctx);
 827
 828    if (target == GL_VERTEX_PROGRAM_ARB) {
 829       prog = ctx->VertexProgram.Current;
 830    }
 831    else if (target == GL_FRAGMENT_PROGRAM_ARB) {
 832       prog = ctx->FragmentProgram.Current;
 833    }
 834    else {
 835       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringARB(target)");
 836       return;
 837    }
 838
 839    assert(prog);
 840
 841    if (pname != GL_PROGRAM_STRING_ARB) {
 842       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringARB(pname)");
 843       return;
 844    }
 845
 846    if (prog->String)
 847       memcpy(dst, prog->String, strlen((char *) prog->String));
 848    else
 849       *dst = '\0';
 850 }