src/mesa/shader/shader_api.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.0
   4  *
   5  * Copyright (C) 2004-2007  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 shader_api.c
  27  * Implementation of GLSL-related API functions
  28  * \author Brian Paul
  29  */
  30
  31 /**
  32  * XXX things to do:
  33  * 1. Check that the right error code is generated for all _mesa_error() calls.
  34  * 2. Insert FLUSH_VERTICES calls in various places
  35  */
  36
  37
  38 #include "main/glheader.h"
  39 #include "main/context.h"
  40 #include "main/hash.h"
  41 #include "main/macros.h"
  42 #include "program.h"
  43 #include "prog_parameter.h"
  44 #include "prog_print.h"
  45 #include "prog_statevars.h"
  46 #include "prog_uniform.h"
  47 #include "shader/shader_api.h"
  48 #include "shader/slang/slang_compile.h"
  49 #include "shader/slang/slang_link.h"
  50
  51
  52
  53 #ifndef GL_PROGRAM_BINARY_LENGTH_OES
  54 #define GL_PROGRAM_BINARY_LENGTH_OES 0x8741
  55 #endif
  56
  57
  58 /**
  59  * Allocate a new gl_shader_program object, initialize it.
  60  */
  61 static struct gl_shader_program *
  62 _mesa_new_shader_program(GLcontext *ctx, GLuint name)
  63 {
  64    struct gl_shader_program *shProg;
  65    shProg = CALLOC_STRUCT(gl_shader_program);
  66    if (shProg) {
  67       shProg->Type = GL_SHADER_PROGRAM_MESA;
  68       shProg->Name = name;
  69       shProg->RefCount = 1;
  70       shProg->Attributes = _mesa_new_parameter_list();
  71    }
  72    return shProg;
  73 }
  74
  75
  76 /**
  77  * Clear (free) the shader program state that gets produced by linking.
  78  */
  79 void
  80 _mesa_clear_shader_program_data(GLcontext *ctx,
  81                                 struct gl_shader_program *shProg)
  82 {
  83    _mesa_reference_vertprog(ctx, &shProg->VertexProgram, NULL);
  84    _mesa_reference_fragprog(ctx, &shProg->FragmentProgram, NULL);
  85
  86    if (shProg->Uniforms) {
  87       _mesa_free_uniform_list(shProg->Uniforms);
  88       shProg->Uniforms = NULL;
  89    }
  90
  91    if (shProg->Varying) {
  92       _mesa_free_parameter_list(shProg->Varying);
  93       shProg->Varying = NULL;
  94    }
  95 }
  96
  97
  98 /**
  99  * Free all the data that hangs off a shader program object, but not the
 100  * object itself.
 101  */
 102 void
 103 _mesa_free_shader_program_data(GLcontext *ctx,
 104                                struct gl_shader_program *shProg)
 105 {
 106    GLuint i;
 107
 108    assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
 109
 110    _mesa_clear_shader_program_data(ctx, shProg);
 111
 112    if (shProg->Attributes) {
 113       _mesa_free_parameter_list(shProg->Attributes);
 114       shProg->Attributes = NULL;
 115    }
 116
 117    /* detach shaders */
 118    for (i = 0; i < shProg->NumShaders; i++) {
 119       _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 120    }
 121    shProg->NumShaders = 0;
 122
 123    if (shProg->Shaders) {
 124       _mesa_free(shProg->Shaders);
 125       shProg->Shaders = NULL;
 126    }
 127
 128    if (shProg->InfoLog) {
 129       _mesa_free(shProg->InfoLog);
 130       shProg->InfoLog = NULL;
 131    }
 132 }
 133
 134
 135 /**
 136  * Free/delete a shader program object.
 137  */
 138 void
 139 _mesa_free_shader_program(GLcontext *ctx, struct gl_shader_program *shProg)
 140 {
 141    _mesa_free_shader_program_data(ctx, shProg);
 142
 143    _mesa_free(shProg);
 144 }
 145
 146
 147 /**
 148  * Set ptr to point to shProg.
 149  * If ptr is pointing to another object, decrement its refcount (and delete
 150  * if refcount hits zero).
 151  * Then set ptr to point to shProg, incrementing its refcount.
 152  */
 153 /* XXX this could be static */
 154 void
 155 _mesa_reference_shader_program(GLcontext *ctx,
 156                                struct gl_shader_program **ptr,
 157                                struct gl_shader_program *shProg)
 158 {
 159    assert(ptr);
 160    if (*ptr == shProg) {
 161       /* no-op */
 162       return;
 163    }
 164    if (*ptr) {
 165       /* Unreference the old shader program */
 166       GLboolean deleteFlag = GL_FALSE;
 167       struct gl_shader_program *old = *ptr;
 168
 169       ASSERT(old->RefCount > 0);
 170       old->RefCount--;
 171 #if 0
 172       printf("ShaderProgram %p ID=%u  RefCount-- to %d\n",
 173              (void *) old, old->Name, old->RefCount);
 174 #endif
 175       deleteFlag = (old->RefCount == 0);
 176
 177       if (deleteFlag) {
 178          _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
 179          _mesa_free_shader_program(ctx, old);
 180       }
 181
 182       *ptr = NULL;
 183    }
 184    assert(!*ptr);
 185
 186    if (shProg) {
 187       shProg->RefCount++;
 188 #if 0
 189       printf("ShaderProgram %p ID=%u  RefCount++ to %d\n",
 190              (void *) shProg, shProg->Name, shProg->RefCount);
 191 #endif
 192       *ptr = shProg;
 193    }
 194 }
 195
 196
 197 /**
 198  * Lookup a GLSL program object.
 199  */
 200 struct gl_shader_program *
 201 _mesa_lookup_shader_program(GLcontext *ctx, GLuint name)
 202 {
 203    struct gl_shader_program *shProg;
 204    if (name) {
 205       shProg = (struct gl_shader_program *)
 206          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 207       /* Note that both gl_shader and gl_shader_program objects are kept
 208        * in the same hash table.  Check the object's type to be sure it's
 209        * what we're expecting.
 210        */
 211       if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
 212          return NULL;
 213       }
 214       return shProg;
 215    }
 216    return NULL;
 217 }
 218
 219
 220 /**
 221  * As above, but record an error if program is not found.
 222  */
 223 static struct gl_shader_program *
 224 _mesa_lookup_shader_program_err(GLcontext *ctx, GLuint name,
 225                                 const char *caller)
 226 {
 227    if (!name) {
 228       _mesa_error(ctx, GL_INVALID_VALUE, caller);
 229       return NULL;
 230    }
 231    else {
 232       struct gl_shader_program *shProg = (struct gl_shader_program *)
 233          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 234       if (!shProg) {
 235          _mesa_error(ctx, GL_INVALID_VALUE, caller);
 236          return NULL;
 237       }
 238       if (shProg->Type != GL_SHADER_PROGRAM_MESA) {
 239          _mesa_error(ctx, GL_INVALID_OPERATION, caller);
 240          return NULL;
 241       }
 242       return shProg;
 243    }
 244 }
 245
 246
 247
 248
 249 /**
 250  * Allocate a new gl_shader object, initialize it.
 251  */
 252 struct gl_shader *
 253 _mesa_new_shader(GLcontext *ctx, GLuint name, GLenum type)
 254 {
 255    struct gl_shader *shader;
 256    assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
 257    shader = CALLOC_STRUCT(gl_shader);
 258    if (shader) {
 259       shader->Type = type;
 260       shader->Name = name;
 261       shader->RefCount = 1;
 262    }
 263    return shader;
 264 }
 265
 266
 267 void
 268 _mesa_free_shader(GLcontext *ctx, struct gl_shader *sh)
 269 {
 270    if (sh->Source)
 271       _mesa_free((void *) sh->Source);
 272    if (sh->InfoLog)
 273       _mesa_free(sh->InfoLog);
 274    _mesa_reference_program(ctx, &sh->Program, NULL);
 275    _mesa_free(sh);
 276 }
 277
 278
 279 /**
 280  * Set ptr to point to sh.
 281  * If ptr is pointing to another shader, decrement its refcount (and delete
 282  * if refcount hits zero).
 283  * Then set ptr to point to sh, incrementing its refcount.
 284  */
 285 /* XXX this could be static */
 286 void
 287 _mesa_reference_shader(GLcontext *ctx, struct gl_shader **ptr,
 288                        struct gl_shader *sh)
 289 {
 290    assert(ptr);
 291    if (*ptr == sh) {
 292       /* no-op */
 293       return;
 294    }
 295    if (*ptr) {
 296       /* Unreference the old shader */
 297       GLboolean deleteFlag = GL_FALSE;
 298       struct gl_shader *old = *ptr;
 299
 300       ASSERT(old->RefCount > 0);
 301       old->RefCount--;
 302       /*printf("SHADER DECR %p (%d) to %d\n",
 303         (void*) old, old->Name, old->RefCount);*/
 304       deleteFlag = (old->RefCount == 0);
 305
 306       if (deleteFlag) {
 307          _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
 308          _mesa_free_shader(ctx, old);
 309       }
 310
 311       *ptr = NULL;
 312    }
 313    assert(!*ptr);
 314
 315    if (sh) {
 316       /* reference new */
 317       sh->RefCount++;
 318       /*printf("SHADER INCR %p (%d) to %d\n",
 319         (void*) sh, sh->Name, sh->RefCount);*/
 320       *ptr = sh;
 321    }
 322 }
 323
 324
 325 /**
 326  * Lookup a GLSL shader object.
 327  */
 328 struct gl_shader *
 329 _mesa_lookup_shader(GLcontext *ctx, GLuint name)
 330 {
 331    if (name) {
 332       struct gl_shader *sh = (struct gl_shader *)
 333          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 334       /* Note that both gl_shader and gl_shader_program objects are kept
 335        * in the same hash table.  Check the object's type to be sure it's
 336        * what we're expecting.
 337        */
 338       if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {
 339          return NULL;
 340       }
 341       return sh;
 342    }
 343    return NULL;
 344 }
 345
 346
 347 /**
 348  * As above, but record an error if shader is not found.
 349  */
 350 static struct gl_shader *
 351 _mesa_lookup_shader_err(GLcontext *ctx, GLuint name, const char *caller)
 352 {
 353    if (!name) {
 354       _mesa_error(ctx, GL_INVALID_VALUE, caller);
 355       return NULL;
 356    }
 357    else {
 358       struct gl_shader *sh = (struct gl_shader *)
 359          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
 360       if (!sh) {
 361          _mesa_error(ctx, GL_INVALID_VALUE, caller);
 362          return NULL;
 363       }
 364       if (sh->Type == GL_SHADER_PROGRAM_MESA) {
 365          _mesa_error(ctx, GL_INVALID_OPERATION, caller);
 366          return NULL;
 367       }
 368       return sh;
 369    }
 370 }
 371
 372
 373
 374 /**
 375  * Initialize context's shader state.
 376  */
 377 void
 378 _mesa_init_shader_state(GLcontext * ctx)
 379 {
 380    /* Device drivers may override these to control what kind of instructions
 381     * are generated by the GLSL compiler.
 382     */
 383    ctx->Shader.EmitHighLevelInstructions = GL_TRUE;
 384    ctx->Shader.EmitCondCodes = GL_FALSE;/*GL_TRUE;*/ /* XXX probably want GL_FALSE... */
 385    ctx->Shader.EmitComments = GL_FALSE;
 386 }
 387
 388
 389 /**
 390  * Free the per-context shader-related state.
 391  */
 392 void
 393 _mesa_free_shader_state(GLcontext *ctx)
 394 {
 395    _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, NULL);
 396 }
 397
 398
 399 /**
 400  * Copy string from <src> to <dst>, up to maxLength characters, returning
 401  * length of <dst> in <length>.
 402  * \param src  the strings source
 403  * \param maxLength  max chars to copy
 404  * \param length  returns number of chars copied
 405  * \param dst  the string destination
 406  */
 407 static void
 408 copy_string(GLchar *dst, GLsizei maxLength, GLsizei *length, const GLchar *src)
 409 {
 410    GLsizei len;
 411    for (len = 0; len < maxLength - 1 && src && src[len]; len++)
 412       dst[len] = src[len];
 413    if (maxLength > 0)
 414       dst[len] = 0;
 415    if (length)
 416       *length = len;
 417 }
 418
 419
 420 static GLboolean
 421 _mesa_is_program(GLcontext *ctx, GLuint name)
 422 {
 423    struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
 424    return shProg ? GL_TRUE : GL_FALSE;
 425 }
 426
 427
 428 static GLboolean
 429 _mesa_is_shader(GLcontext *ctx, GLuint name)
 430 {
 431    struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
 432    return shader ? GL_TRUE : GL_FALSE;
 433 }
 434
 435
 436 /**
 437  * Called via ctx->Driver.AttachShader()
 438  */
 439 static void
 440 _mesa_attach_shader(GLcontext *ctx, GLuint program, GLuint shader)
 441 {
 442    struct gl_shader_program *shProg;
 443    struct gl_shader *sh;
 444    GLuint i, n;
 445
 446    shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
 447    if (!shProg)
 448       return;
 449
 450    sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
 451    if (!sh) {
 452       return;
 453    }
 454
 455    n = shProg->NumShaders;
 456    for (i = 0; i < n; i++) {
 457       if (shProg->Shaders[i] == sh) {
 458          /* already attached */
 459          return;
 460       }
 461    }
 462
 463    /* grow list */
 464    shProg->Shaders = (struct gl_shader **)
 465       _mesa_realloc(shProg->Shaders,
 466                     n * sizeof(struct gl_shader *),
 467                     (n + 1) * sizeof(struct gl_shader *));
 468    if (!shProg->Shaders) {
 469       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
 470       return;
 471    }
 472
 473    /* append */
 474    shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
 475    _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
 476    shProg->NumShaders++;
 477 }
 478
 479
 480 static GLint
 481 _mesa_get_attrib_location(GLcontext *ctx, GLuint program,
 482                           const GLchar *name)
 483 {
 484    struct gl_shader_program *shProg
 485       = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");
 486
 487    if (!shProg) {
 488       return -1;
 489    }
 490
 491    if (!shProg->LinkStatus) {
 492       _mesa_error(ctx, GL_INVALID_OPERATION,
 493                   "glGetAttribLocation(program not linked)");
 494       return -1;
 495    }
 496
 497    if (!name)
 498       return -1;
 499
 500    if (shProg->Attributes) {
 501       GLint i = _mesa_lookup_parameter_index(shProg->Attributes, -1, name);
 502       if (i >= 0) {
 503          return shProg->Attributes->Parameters[i].StateIndexes[0];
 504       }
 505    }
 506    return -1;
 507 }
 508
 509
 510 static void
 511 _mesa_bind_attrib_location(GLcontext *ctx, GLuint program, GLuint index,
 512                            const GLchar *name)
 513 {
 514    struct gl_shader_program *shProg;
 515    const GLint size = -1; /* unknown size */
 516    GLint i, oldIndex;
 517    GLenum datatype = GL_FLOAT_VEC4;
 518
 519    shProg = _mesa_lookup_shader_program_err(ctx, program,
 520                                             "glBindAttribLocation");
 521    if (!shProg) {
 522       return;
 523    }
 524
 525    if (!name)
 526       return;
 527
 528    if (strncmp(name, "gl_", 3) == 0) {
 529       _mesa_error(ctx, GL_INVALID_OPERATION,
 530                   "glBindAttribLocation(illegal name)");
 531       return;
 532    }
 533
 534    if (index >= ctx->Const.VertexProgram.MaxAttribs) {
 535       _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");
 536       return;
 537    }
 538
 539    if (shProg->LinkStatus) {
 540       /* get current index/location for the attribute */
 541       oldIndex = _mesa_get_attrib_location(ctx, program, name);
 542    }
 543    else {
 544       oldIndex = -1;
 545    }
 546
 547    /* this will replace the current value if it's already in the list */
 548    i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);
 549    if (i < 0) {
 550       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
 551       return;
 552    }
 553
 554    if (shProg->VertexProgram && oldIndex >= 0 && oldIndex != index) {
 555       /* If the index changed, need to search/replace references to that attribute
 556        * in the vertex program.
 557        */
 558       _slang_remap_attribute(&shProg->VertexProgram->Base, oldIndex, index);
 559    }
 560 }
 561
 562
 563 static GLuint
 564 _mesa_create_shader(GLcontext *ctx, GLenum type)
 565 {
 566    struct gl_shader *sh;
 567    GLuint name;
 568
 569    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 570
 571    switch (type) {
 572    case GL_FRAGMENT_SHADER:
 573    case GL_VERTEX_SHADER:
 574       sh = _mesa_new_shader(ctx, name, type);
 575       break;
 576    default:
 577       _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
 578       return 0;
 579    }
 580
 581    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
 582
 583    return name;
 584 }
 585
 586
 587 static GLuint
 588 _mesa_create_program(GLcontext *ctx)
 589 {
 590    GLuint name;
 591    struct gl_shader_program *shProg;
 592
 593    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 594    shProg = _mesa_new_shader_program(ctx, name);
 595
 596    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
 597
 598    assert(shProg->RefCount == 1);
 599
 600    return name;
 601 }
 602
 603
 604 /**
 605  * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
 606  * DeleteProgramARB.
 607  */
 608 static void
 609 _mesa_delete_program2(GLcontext *ctx, GLuint name)
 610 {
 611    /*
 612     * NOTE: deleting shaders/programs works a bit differently than
 613     * texture objects (and buffer objects, etc).  Shader/program
 614     * handles/IDs exist in the hash table until the object is really
 615     * deleted (refcount==0).  With texture objects, the handle/ID is
 616     * removed from the hash table in glDeleteTextures() while the tex
 617     * object itself might linger until its refcount goes to zero.
 618     */
 619    struct gl_shader_program *shProg;
 620
 621    shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
 622    if (!shProg)
 623       return;
 624
 625    shProg->DeletePending = GL_TRUE;
 626
 627    /* effectively, decr shProg's refcount */
 628    _mesa_reference_shader_program(ctx, &shProg, NULL);
 629 }
 630
 631
 632 static void
 633 _mesa_delete_shader(GLcontext *ctx, GLuint shader)
 634 {
 635    struct gl_shader *sh;
 636
 637    sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
 638    if (!sh)
 639       return;
 640
 641    sh->DeletePending = GL_TRUE;
 642
 643    /* effectively, decr sh's refcount */
 644    _mesa_reference_shader(ctx, &sh, NULL);
 645 }
 646
 647
 648 static void
 649 _mesa_detach_shader(GLcontext *ctx, GLuint program, GLuint shader)
 650 {
 651    struct gl_shader_program *shProg;
 652    GLuint n;
 653    GLuint i, j;
 654
 655    shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
 656    if (!shProg)
 657       return;
 658
 659    n = shProg->NumShaders;
 660
 661    for (i = 0; i < n; i++) {
 662       if (shProg->Shaders[i]->Name == shader) {
 663          /* found it */
 664          struct gl_shader **newList;
 665
 666          /* release */
 667          _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 668
 669          /* alloc new, smaller array */
 670          newList = (struct gl_shader **)
 671             _mesa_malloc((n - 1) * sizeof(struct gl_shader *));
 672          if (!newList) {
 673             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
 674             return;
 675          }
 676          for (j = 0; j < i; j++) {
 677             newList[j] = shProg->Shaders[j];
 678          }
 679          while (++i < n)
 680             newList[j++] = shProg->Shaders[i];
 681          _mesa_free(shProg->Shaders);
 682
 683          shProg->Shaders = newList;
 684          shProg->NumShaders = n - 1;
 685
 686 #ifdef DEBUG
 687          /* sanity check */
 688          {
 689             for (j = 0; j < shProg->NumShaders; j++) {
 690                assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
 691                       shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
 692                assert(shProg->Shaders[j]->RefCount > 0);
 693             }
 694          }
 695 #endif
 696
 697          return;
 698       }
 699    }
 700
 701    /* not found */
 702    {
 703       GLenum err;
 704       if (_mesa_is_shader(ctx, shader))
 705          err = GL_INVALID_OPERATION;
 706       else if (_mesa_is_program(ctx, shader))
 707          err = GL_INVALID_OPERATION;
 708       else
 709          err = GL_INVALID_VALUE;
 710       _mesa_error(ctx, err, "glDetachProgram(shader)");
 711       return;
 712    }
 713 }
 714
 715
 716 static GLint
 717 sizeof_glsl_type(GLenum type)
 718 {
 719    switch (type) {
 720    case GL_FLOAT:
 721    case GL_INT:
 722    case GL_BOOL:
 723       return 1;
 724    case GL_FLOAT_VEC2:
 725    case GL_INT_VEC2:
 726    case GL_BOOL_VEC2:
 727       return 2;
 728    case GL_FLOAT_VEC3:
 729    case GL_INT_VEC3:
 730    case GL_BOOL_VEC3:
 731       return 3;
 732    case GL_FLOAT_VEC4:
 733    case GL_INT_VEC4:
 734    case GL_BOOL_VEC4:
 735       return 4;
 736    case GL_FLOAT_MAT2:
 737    case GL_FLOAT_MAT2x3:
 738    case GL_FLOAT_MAT2x4:
 739       return 8; /* two float[4] vectors */
 740    case GL_FLOAT_MAT3:
 741    case GL_FLOAT_MAT3x2:
 742    case GL_FLOAT_MAT3x4:
 743       return 12; /* three float[4] vectors */
 744    case GL_FLOAT_MAT4:
 745    case GL_FLOAT_MAT4x2:
 746    case GL_FLOAT_MAT4x3:
 747       return 16;  /* four float[4] vectors */
 748    default:
 749       _mesa_problem(NULL, "Invalid type in sizeof_glsl_type()");
 750       return 1;
 751    }
 752 }
 753
 754
 755 static GLboolean
 756 is_boolean_type(GLenum type)
 757 {
 758    switch (type) {
 759    case GL_BOOL:
 760    case GL_BOOL_VEC2:
 761    case GL_BOOL_VEC3:
 762    case GL_BOOL_VEC4:
 763       return GL_TRUE;
 764    default:
 765       return GL_FALSE;
 766    }
 767 }
 768
 769
 770 static GLboolean
 771 is_integer_type(GLenum type)
 772 {
 773    switch (type) {
 774    case GL_INT:
 775    case GL_INT_VEC2:
 776    case GL_INT_VEC3:
 777    case GL_INT_VEC4:
 778       return GL_TRUE;
 779    default:
 780       return GL_FALSE;
 781    }
 782 }
 783
 784
 785 static void
 786 _mesa_get_active_attrib(GLcontext *ctx, GLuint program, GLuint index,
 787                         GLsizei maxLength, GLsizei *length, GLint *size,
 788                         GLenum *type, GLchar *nameOut)
 789 {
 790    struct gl_shader_program *shProg;
 791
 792    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
 793    if (!shProg)
 794       return;
 795
 796    if (!shProg->Attributes || index >= shProg->Attributes->NumParameters) {
 797       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
 798       return;
 799    }
 800
 801    copy_string(nameOut, maxLength, length,
 802                shProg->Attributes->Parameters[index].Name);
 803    if (size)
 804       *size = shProg->Attributes->Parameters[index].Size
 805          / sizeof_glsl_type(shProg->Attributes->Parameters[index].DataType);
 806    if (type)
 807       *type = shProg->Attributes->Parameters[index].DataType;
 808 }
 809
 810
 811 static struct gl_program_parameter *
 812 get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)
 813 {
 814    const struct gl_program *prog;
 815    GLint progPos;
 816
 817    progPos = shProg->Uniforms->Uniforms[index].VertPos;
 818    if (progPos >= 0) {
 819       prog = &shProg->VertexProgram->Base;
 820    }
 821    else {
 822       progPos = shProg->Uniforms->Uniforms[index].FragPos;
 823       if (progPos >= 0) {
 824          prog = &shProg->FragmentProgram->Base;
 825       }
 826    }
 827
 828    if (!prog || progPos < 0)
 829       return NULL; /* should never happen */
 830
 831    return &prog->Parameters->Parameters[progPos];
 832 }
 833
 834
 835 /**
 836  * Called via ctx->Driver.GetActiveUniform().
 837  */
 838 static void
 839 _mesa_get_active_uniform(GLcontext *ctx, GLuint program, GLuint index,
 840                          GLsizei maxLength, GLsizei *length, GLint *size,
 841                          GLenum *type, GLchar *nameOut)
 842 {
 843    const struct gl_shader_program *shProg;
 844    const struct gl_program *prog;
 845    GLint progPos;
 846
 847    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
 848    if (!shProg)
 849       return;
 850
 851    if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {
 852       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
 853       return;
 854    }
 855
 856    progPos = shProg->Uniforms->Uniforms[index].VertPos;
 857    if (progPos >= 0) {
 858       prog = &shProg->VertexProgram->Base;
 859    }
 860    else {
 861       progPos = shProg->Uniforms->Uniforms[index].FragPos;
 862       if (progPos >= 0) {
 863          prog = &shProg->FragmentProgram->Base;
 864       }
 865    }
 866
 867    if (!prog || progPos < 0)
 868       return; /* should never happen */
 869
 870    if (nameOut)
 871       copy_string(nameOut, maxLength, length,
 872                   prog->Parameters->Parameters[progPos].Name);
 873    if (size)
 874       *size = prog->Parameters->Parameters[progPos].Size
 875          / sizeof_glsl_type(prog->Parameters->Parameters[progPos].DataType);
 876    if (type)
 877       *type = prog->Parameters->Parameters[progPos].DataType;
 878 }
 879
 880
 881 /**
 882  * Called via ctx->Driver.GetAttachedShaders().
 883  */
 884 static void
 885 _mesa_get_attached_shaders(GLcontext *ctx, GLuint program, GLsizei maxCount,
 886                            GLsizei *count, GLuint *obj)
 887 {
 888    struct gl_shader_program *shProg =
 889       _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
 890    if (shProg) {
 891       GLuint i;
 892       for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
 893          obj[i] = shProg->Shaders[i]->Name;
 894       }
 895       if (count)
 896          *count = i;
 897    }
 898 }
 899
 900
 901 static GLuint
 902 _mesa_get_handle(GLcontext *ctx, GLenum pname)
 903 {
 904 #if 0
 905    GET_CURRENT_CONTEXT(ctx);
 906
 907    switch (pname) {
 908    case GL_PROGRAM_OBJECT_ARB:
 909       {
 910          struct gl2_program_intf **pro = ctx->Shader.CurrentProgram;
 911
 912          if (pro != NULL)
 913             return (**pro)._container._generic.
 914                GetName((struct gl2_generic_intf **) (pro));
 915       }
 916       break;
 917    default:
 918       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
 919    }
 920 #endif
 921    return 0;
 922 }
 923
 924
 925 static void
 926 _mesa_get_programiv(GLcontext *ctx, GLuint program,
 927                     GLenum pname, GLint *params)
 928 {
 929    struct gl_shader_program *shProg
 930       = _mesa_lookup_shader_program(ctx, program);
 931
 932    if (!shProg) {
 933       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
 934       return;
 935    }
 936
 937    switch (pname) {
 938    case GL_DELETE_STATUS:
 939       *params = shProg->DeletePending;
 940       break;
 941    case GL_LINK_STATUS:
 942       *params = shProg->LinkStatus;
 943       break;
 944    case GL_VALIDATE_STATUS:
 945       *params = shProg->Validated;
 946       break;
 947    case GL_INFO_LOG_LENGTH:
 948       *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
 949       break;
 950    case GL_ATTACHED_SHADERS:
 951       *params = shProg->NumShaders;
 952       break;
 953    case GL_ACTIVE_ATTRIBUTES:
 954       *params = shProg->Attributes ? shProg->Attributes->NumParameters : 0;
 955       break;
 956    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 957       *params = _mesa_longest_parameter_name(shProg->Attributes,
 958                                              PROGRAM_INPUT) + 1;
 959       break;
 960    case GL_ACTIVE_UNIFORMS:
 961       *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;
 962       break;
 963    case GL_ACTIVE_UNIFORM_MAX_LENGTH:
 964       *params = _mesa_longest_uniform_name(shProg->Uniforms);
 965       if (*params > 0)
 966          (*params)++;  /* add one for terminating zero */
 967       break;
 968    case GL_PROGRAM_BINARY_LENGTH_OES:
 969       *params = 0;
 970       break;
 971    default:
 972       _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
 973       return;
 974    }
 975 }
 976
 977
 978 static void
 979 _mesa_get_shaderiv(GLcontext *ctx, GLuint name, GLenum pname, GLint *params)
 980 {
 981    struct gl_shader *shader = _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
 982
 983    if (!shader) {
 984       return;
 985    }
 986
 987    switch (pname) {
 988    case GL_SHADER_TYPE:
 989       *params = shader->Type;
 990       break;
 991    case GL_DELETE_STATUS:
 992       *params = shader->DeletePending;
 993       break;
 994    case GL_COMPILE_STATUS:
 995       *params = shader->CompileStatus;
 996       break;
 997    case GL_INFO_LOG_LENGTH:
 998       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
 999       break;
1000    case GL_SHADER_SOURCE_LENGTH:
1001       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
1002       break;
1003    default:
1004       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
1005       return;
1006    }
1007 }
1008
1009
1010 static void
1011 _mesa_get_program_info_log(GLcontext *ctx, GLuint program, GLsizei bufSize,
1012                            GLsizei *length, GLchar *infoLog)
1013 {
1014    struct gl_shader_program *shProg
1015       = _mesa_lookup_shader_program(ctx, program);
1016    if (!shProg) {
1017       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
1018       return;
1019    }
1020    copy_string(infoLog, bufSize, length, shProg->InfoLog);
1021 }
1022
1023
1024 static void
1025 _mesa_get_shader_info_log(GLcontext *ctx, GLuint shader, GLsizei bufSize,
1026                           GLsizei *length, GLchar *infoLog)
1027 {
1028    struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
1029    if (!sh) {
1030       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
1031       return;
1032    }
1033    copy_string(infoLog, bufSize, length, sh->InfoLog);
1034 }
1035
1036
1037 /**
1038  * Called via ctx->Driver.GetShaderSource().
1039  */
1040 static void
1041 _mesa_get_shader_source(GLcontext *ctx, GLuint shader, GLsizei maxLength,
1042                         GLsizei *length, GLchar *sourceOut)
1043 {
1044    struct gl_shader *sh;
1045    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
1046    if (!sh) {
1047       return;
1048    }
1049    copy_string(sourceOut, maxLength, length, sh->Source);
1050 }
1051
1052
1053 static void
1054 get_matrix_dims(GLenum type, GLint *rows, GLint *cols)
1055 {
1056    switch (type) {
1057    case GL_FLOAT_MAT2:
1058       *rows = *cols = 2;
1059       break;
1060    case GL_FLOAT_MAT2x3:
1061       *rows = 3;
1062       *cols = 2;
1063       break;
1064    case GL_FLOAT_MAT2x4:
1065       *rows = 4;
1066       *cols = 2;
1067       break;
1068    case GL_FLOAT_MAT3:
1069       *rows = 3;
1070       *cols = 3;
1071       break;
1072    case GL_FLOAT_MAT3x2:
1073       *rows = 2;
1074       *cols = 3;
1075       break;
1076    case GL_FLOAT_MAT3x4:
1077       *rows = 4;
1078       *cols = 3;
1079       break;
1080    case GL_FLOAT_MAT4:
1081       *rows = 4;
1082       *cols = 4;
1083       break;
1084    case GL_FLOAT_MAT4x2:
1085       *rows = 2;
1086       *cols = 4;
1087       break;
1088    case GL_FLOAT_MAT4x3:
1089       *rows = 3;
1090       *cols = 4;
1091       break;
1092    default:
1093       *rows = *cols = 0;
1094    }
1095 }
1096
1097
1098 /**
1099  * Determine the number of rows and columns occupied by a uniform
1100  * according to its datatype.
1101  */
1102 static void
1103 get_uniform_rows_cols(const struct gl_program_parameter *p,
1104                       GLint *rows, GLint *cols)
1105 {
1106    get_matrix_dims(p->DataType, rows, cols);
1107    if (*rows == 0 && *cols == 0) {
1108       /* not a matrix type, probably a float or vector */
1109       *rows = p->Size / 4 + 1;
1110       if (p->Size % 4 == 0)
1111          *cols = 4;
1112       else
1113          *cols = p->Size % 4;
1114    }
1115 }
1116
1117
1118 #define MAX_UNIFORM_ELEMENTS 16
1119
1120 /**
1121  * Helper for GetUniformfv(), GetUniformiv()
1122  * Returns number of elements written to 'params' output.
1123  */
1124 static GLuint
1125 get_uniformfv(GLcontext *ctx, GLuint program, GLint location,
1126               GLfloat *params)
1127 {
1128    struct gl_shader_program *shProg
1129       = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");
1130    if (shProg) {
1131       if (shProg->Uniforms &&
1132           location >= 0 && location < (GLint) shProg->Uniforms->NumUniforms) {
1133          GLint progPos;
1134          const struct gl_program *prog = NULL;
1135
1136          progPos = shProg->Uniforms->Uniforms[location].VertPos;
1137          if (progPos >= 0) {
1138             prog = &shProg->VertexProgram->Base;
1139          }
1140          else {
1141             progPos = shProg->Uniforms->Uniforms[location].FragPos;
1142             if (progPos >= 0) {
1143                prog = &shProg->FragmentProgram->Base;
1144             }
1145          }
1146
1147          ASSERT(prog);
1148          if (prog) {
1149             const struct gl_program_parameter *p =
1150                &prog->Parameters->Parameters[progPos];
1151             GLint rows, cols, i, j, k;
1152
1153             /* See uniformiv() below */
1154             assert(p->Size <= MAX_UNIFORM_ELEMENTS);
1155
1156             get_uniform_rows_cols(p, &rows, &cols);
1157
1158             k = 0;
1159             for (i = 0; i < rows; i++) {
1160                for (j = 0; j < cols; j++ ) {
1161                   params[k++] = prog->Parameters->ParameterValues[progPos+i][j];
1162                }
1163             }
1164
1165             return p->Size;
1166          }
1167       }
1168       else {
1169          _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(location)");
1170       }
1171    }
1172    return 0;
1173 }
1174
1175
1176 /**
1177  * Called via ctx->Driver.GetUniformfv().
1178  */
1179 static void
1180 _mesa_get_uniformfv(GLcontext *ctx, GLuint program, GLint location,
1181                     GLfloat *params)
1182 {
1183    (void) get_uniformfv(ctx, program, location, params);
1184 }
1185
1186
1187 /**
1188  * Called via ctx->Driver.GetUniformiv().
1189  */
1190 static void
1191 _mesa_get_uniformiv(GLcontext *ctx, GLuint program, GLint location,
1192                     GLint *params)
1193 {
1194    GLfloat fparams[MAX_UNIFORM_ELEMENTS];
1195    GLuint n = get_uniformfv(ctx, program, location, fparams);
1196    GLuint i;
1197    assert(n <= MAX_UNIFORM_ELEMENTS);
1198    for (i = 0; i < n; i++) {
1199       params[i] = (GLint) fparams[i];
1200    }
1201 }
1202
1203
1204 /**
1205  * The value returned by GetUniformLocation actually encodes two things:
1206  * 1. the index into the prog->Uniforms[] array for the uniform
1207  * 2. an offset in the prog->ParameterValues[] array for specifying array
1208  *    elements or structure fields.
1209  * This function merges those two values.
1210  */
1211 static void
1212 merge_location_offset(GLint *location, GLint offset)
1213 {
1214    *location = *location | (offset << 16);
1215 }
1216
1217
1218 /**
1219  * Seperate the uniform location and parameter offset.  See above.
1220  */
1221 static void
1222 split_location_offset(GLint *location, GLint *offset)
1223 {
1224    *offset = (*location >> 16);
1225    *location = *location & 0xffff;
1226 }
1227
1228
1229 /**
1230  * Called via ctx->Driver.GetUniformLocation().
1231  *
1232  * The return value will encode two values, the uniform location and an
1233  * offset (used for arrays, structs).
1234  */
1235 static GLint
1236 _mesa_get_uniform_location(GLcontext *ctx, GLuint program, const GLchar *name)
1237 {
1238    GLint offset = 0, location = -1;
1239
1240    struct gl_shader_program *shProg =
1241       _mesa_lookup_shader_program_err(ctx, program, "glGetUniformLocation");
1242
1243    if (!shProg)
1244       return -1;
1245
1246    if (shProg->LinkStatus == GL_FALSE) {
1247       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");
1248       return -1;
1249    }
1250
1251    /* XXX we should return -1 if the uniform was declared, but not
1252     * actually used.
1253     */
1254
1255    /* XXX we need to be able to parse uniform names for structs and arrays
1256     * such as:
1257     *   mymatrix[1]
1258     *   mystruct.field1
1259     */
1260
1261    {
1262       /* handle 1-dimension arrays here... */
1263       char *c = strchr(name, '[');
1264       if (c) {
1265          /* truncate name at [ */
1266          const GLint len = c - name;
1267          GLchar *newName = _mesa_malloc(len + 1);
1268          if (!newName)
1269             return -1; /* out of mem */
1270          _mesa_memcpy(newName, name, len);
1271          newName[len] = 0;
1272
1273          location = _mesa_lookup_uniform(shProg->Uniforms, newName);
1274          if (location >= 0) {
1275             const GLint element = _mesa_atoi(c + 1);
1276             if (element > 0) {
1277                /* get type of the uniform array element */
1278                struct gl_program_parameter *p;
1279                p = get_uniform_parameter(shProg, location);
1280                if (p) {
1281                   GLint rows, cols;
1282                   get_matrix_dims(p->DataType, &rows, &cols);
1283                   if (rows < 1)
1284                      rows = 1;
1285                   offset = element * rows;
1286                }
1287             }
1288          }
1289
1290          _mesa_free(newName);
1291       }
1292    }
1293
1294    if (location < 0) {
1295       location = _mesa_lookup_uniform(shProg->Uniforms, name);
1296    }
1297
1298    if (location >= 0) {
1299       merge_location_offset(&location, offset);
1300    }
1301
1302    return location;
1303 }
1304
1305
1306
1307 /**
1308  * Called via ctx->Driver.ShaderSource()
1309  */
1310 static void
1311 _mesa_shader_source(GLcontext *ctx, GLuint shader, const GLchar *source)
1312 {
1313    struct gl_shader *sh;
1314
1315    sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
1316    if (!sh)
1317       return;
1318
1319    /* free old shader source string and install new one */
1320    if (sh->Source) {
1321       _mesa_free((void *) sh->Source);
1322    }
1323    sh->Source = source;
1324    sh->CompileStatus = GL_FALSE;
1325 }
1326
1327
1328 /**
1329  * Called via ctx->Driver.CompileShader()
1330  */
1331 static void
1332 _mesa_compile_shader(GLcontext *ctx, GLuint shaderObj)
1333 {
1334    struct gl_shader *sh;
1335
1336    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
1337    if (!sh)
1338       return;
1339
1340    sh->CompileStatus = _slang_compile(ctx, sh);
1341 }
1342
1343
1344 /**
1345  * Called via ctx->Driver.LinkProgram()
1346  */
1347 static void
1348 _mesa_link_program(GLcontext *ctx, GLuint program)
1349 {
1350    struct gl_shader_program *shProg;
1351
1352    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
1353    if (!shProg)
1354       return;
1355
1356    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1357
1358    _slang_link(ctx, program, shProg);
1359 }
1360
1361
1362 /**
1363  * Called via ctx->Driver.UseProgram()
1364  */
1365 void
1366 _mesa_use_program(GLcontext *ctx, GLuint program)
1367 {
1368    struct gl_shader_program *shProg;
1369
1370    if (ctx->Shader.CurrentProgram &&
1371        ctx->Shader.CurrentProgram->Name == program) {
1372       /* no-op */
1373       return;
1374    }
1375
1376    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1377
1378    if (program) {
1379       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1380       if (!shProg) {
1381          return;
1382       }
1383       if (!shProg->LinkStatus) {
1384          _mesa_error(ctx, GL_INVALID_OPERATION, "glUseProgram");
1385          return;
1386       }
1387    }
1388    else {
1389       shProg = NULL;
1390    }
1391
1392    _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, shProg);
1393 }
1394
1395
1396
1397 /**
1398  * Update the vertex and fragment program's TexturesUsed arrays.
1399  */
1400 static void
1401 update_textures_used(struct gl_program *prog)
1402 {
1403    GLuint s;
1404
1405    memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));
1406
1407    for (s = 0; s < MAX_SAMPLERS; s++) {
1408       if (prog->SamplersUsed & (1 << s)) {
1409          GLuint u = prog->SamplerUnits[s];
1410          GLuint t = prog->SamplerTargets[s];
1411          assert(u < MAX_TEXTURE_IMAGE_UNITS);
1412          prog->TexturesUsed[u] |= (1 << t);
1413       }
1414    }
1415 }
1416
1417
1418 static GLboolean
1419 is_sampler_type(GLenum type)
1420 {
1421    switch (type) {
1422    case GL_SAMPLER_1D:
1423    case GL_SAMPLER_2D:
1424    case GL_SAMPLER_3D:
1425    case GL_SAMPLER_CUBE:
1426    case GL_SAMPLER_1D_SHADOW:
1427    case GL_SAMPLER_2D_SHADOW:
1428    case GL_SAMPLER_2D_RECT_ARB:
1429    case GL_SAMPLER_2D_RECT_SHADOW_ARB:
1430    case GL_SAMPLER_1D_ARRAY_EXT:
1431    case GL_SAMPLER_2D_ARRAY_EXT:
1432       return GL_TRUE;
1433    default:
1434       return GL_FALSE;
1435    }
1436 }
1437
1438
1439 /**
1440  * Check if the type given by userType is allowed to set a uniform of the
1441  * target type.  Generally, equivalence is required, but setting Boolean
1442  * uniforms can be done with glUniformiv or glUniformfv.
1443  */
1444 static GLboolean
1445 compatible_types(GLenum userType, GLenum targetType)
1446 {
1447    if (userType == targetType)
1448       return GL_TRUE;
1449
1450    if (targetType == GL_BOOL && (userType == GL_FLOAT || userType == GL_INT))
1451       return GL_TRUE;
1452
1453    if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||
1454                                       userType == GL_INT_VEC2))
1455       return GL_TRUE;
1456
1457    if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||
1458                                       userType == GL_INT_VEC3))
1459       return GL_TRUE;
1460
1461    if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||
1462                                       userType == GL_INT_VEC4))
1463       return GL_TRUE;
1464
1465    if (is_sampler_type(targetType) && userType == GL_INT)
1466       return GL_TRUE;
1467
1468    return GL_FALSE;
1469 }
1470
1471
1472 /**
1473  * Set the value of a program's uniform variable.
1474  * \param program  the program whose uniform to update
1475  * \param index  the index of the program parameter for the uniform
1476  * \param offset  additional parameter slot offset (for arrays)
1477  * \param type  the datatype of the uniform
1478  * \param count  the number of uniforms to set
1479  * \param elems  number of elements per uniform
1480  * \param values  the new values
1481  */
1482 static void
1483 set_program_uniform(GLcontext *ctx, struct gl_program *program,
1484                     GLint index, GLint offset,
1485                     GLenum type, GLsizei count, GLint elems,
1486                     const void *values)
1487 {
1488    assert(offset >= 0);
1489
1490    if (!compatible_types(type,
1491                          program->Parameters->Parameters[index].DataType)) {
1492       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
1493       return;
1494    }
1495
1496    if (index + offset > program->Parameters->Size) {
1497       /* out of bounds! */
1498       return;
1499    }
1500
1501    if (program->Parameters->Parameters[index].Type == PROGRAM_SAMPLER) {
1502       /* This controls which texture unit which is used by a sampler */
1503       GLuint texUnit, sampler;
1504
1505       /* data type for setting samplers must be int */
1506       if (type != GL_INT || count != 1) {
1507          _mesa_error(ctx, GL_INVALID_OPERATION,
1508                      "glUniform(only glUniform1i can be used "
1509                      "to set sampler uniforms)");
1510          return;
1511       }
1512
1513       sampler = (GLuint) program->Parameters->ParameterValues[index][0];
1514       texUnit = ((GLuint *) values)[0];
1515
1516       /* check that the sampler (tex unit index) is legal */
1517       if (texUnit >= ctx->Const.MaxTextureImageUnits) {
1518          _mesa_error(ctx, GL_INVALID_VALUE,
1519                      "glUniform1(invalid sampler/tex unit index)");
1520          return;
1521       }
1522
1523       /* This maps a sampler to a texture unit: */
1524       program->SamplerUnits[sampler] = texUnit;
1525       update_textures_used(program);
1526
1527       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1528    }
1529    else {
1530       /* ordinary uniform variable */
1531       GLsizei k, i;
1532       GLint slots = (program->Parameters->Parameters[index].Size + 3) / 4;
1533
1534       if (count * elems > (GLint) program->Parameters->Parameters[index].Size) {
1535          _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(count too large)");
1536          return;
1537       }
1538
1539       if (count > slots)
1540          count = slots;
1541
1542       for (k = 0; k < count; k++) {
1543          GLfloat *uniformVal = program->Parameters->ParameterValues[index + offset + k];
1544          if (is_integer_type(type)) {
1545             const GLint *iValues = ((const GLint *) values) + k * elems;
1546             for (i = 0; i < elems; i++) {
1547                uniformVal[i] = (GLfloat) iValues[i];
1548             }
1549          }
1550          else {
1551             const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
1552             for (i = 0; i < elems; i++) {
1553                uniformVal[i] = fValues[i];
1554             }
1555          }
1556
1557          /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
1558          if (is_boolean_type(program->Parameters->Parameters[index].DataType)) {
1559             for (i = 0; i < elems; i++) {
1560                uniformVal[i] = uniformVal[i] ? 1.0 : 0.0;
1561             }
1562          }
1563       }
1564    }
1565 }
1566
1567
1568 /**
1569  * Called via ctx->Driver.Uniform().
1570  */
1571 static void
1572 _mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
1573               const GLvoid *values, GLenum type)
1574 {
1575    struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
1576    GLint elems, offset;
1577
1578    if (!shProg || !shProg->LinkStatus) {
1579       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
1580       return;
1581    }
1582
1583    if (location == -1)
1584       return;   /* The standard specifies this as a no-op */
1585
1586    split_location_offset(&location, &offset);
1587
1588    if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
1589       _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location)");
1590       return;
1591    }
1592
1593    if (count < 0) {
1594       _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");
1595       return;
1596    }
1597
1598    switch (type) {
1599    case GL_FLOAT:
1600    case GL_INT:
1601       elems = 1;
1602       break;
1603    case GL_FLOAT_VEC2:
1604    case GL_INT_VEC2:
1605       elems = 2;
1606       break;
1607    case GL_FLOAT_VEC3:
1608    case GL_INT_VEC3:
1609       elems = 3;
1610       break;
1611    case GL_FLOAT_VEC4:
1612    case GL_INT_VEC4:
1613       elems = 4;
1614       break;
1615    default:
1616       _mesa_problem(ctx, "Invalid type in _mesa_uniform");
1617       return;
1618    }
1619
1620    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1621
1622    /* A uniform var may be used by both a vertex shader and a fragment
1623     * shader.  We may need to update one or both shader's uniform here:
1624     */
1625    if (shProg->VertexProgram) {
1626       /* convert uniform location to program parameter index */
1627       GLint index = shProg->Uniforms->Uniforms[location].VertPos;
1628       if (index >= 0) {
1629          set_program_uniform(ctx, &shProg->VertexProgram->Base,
1630                              index, offset, type, count, elems, values);
1631       }
1632    }
1633
1634    if (shProg->FragmentProgram) {
1635       /* convert uniform location to program parameter index */
1636       GLint index = shProg->Uniforms->Uniforms[location].FragPos;
1637       if (index >= 0) {
1638          set_program_uniform(ctx, &shProg->FragmentProgram->Base,
1639                              index, offset, type, count, elems, values);
1640       }
1641    }
1642 }
1643
1644
1645 /**
1646  * Set a matrix-valued program parameter.
1647  */
1648 static void
1649 set_program_uniform_matrix(GLcontext *ctx, struct gl_program *program,
1650                            GLuint index, GLuint offset,
1651                            GLuint count, GLuint rows, GLuint cols,
1652                            GLboolean transpose, const GLfloat *values)
1653 {
1654    GLuint mat, row, col;
1655    GLuint dst = index + offset, src = 0;
1656    GLint nr, nc;
1657
1658    /* check that the number of rows, columns is correct */
1659    get_matrix_dims(program->Parameters->Parameters[index].DataType, &nr, &nc);
1660    if (rows != nr || cols != nc) {
1661       _mesa_error(ctx, GL_INVALID_OPERATION,
1662                   "glUniformMatrix(matrix size mismatch)");
1663       return;
1664    }
1665
1666    if (index + offset > program->Parameters->Size) {
1667       /* out of bounds! */
1668       return;
1669    }
1670
1671    /*
1672     * Note: the _columns_ of a matrix are stored in program registers, not
1673     * the rows.  So, the loops below look a little funny.
1674     * XXX could optimize this a bit...
1675     */
1676
1677    /* loop over matrices */
1678    for (mat = 0; mat < count; mat++) {
1679
1680       /* each matrix: */
1681       for (col = 0; col < cols; col++) {
1682          GLfloat *v = program->Parameters->ParameterValues[dst];
1683          for (row = 0; row < rows; row++) {
1684             if (transpose) {
1685                v[row] = values[src + row * cols + col];
1686             }
1687             else {
1688                v[row] = values[src + col * rows + row];
1689             }
1690          }
1691          dst++;
1692       }
1693
1694       src += rows * cols;  /* next matrix */
1695    }
1696 }
1697
1698
1699 /**
1700  * Called by ctx->Driver.UniformMatrix().
1701  * Note: cols=2, rows=4  ==>  array[2] of vec4
1702  */
1703 static void
1704 _mesa_uniform_matrix(GLcontext *ctx, GLint cols, GLint rows,
1705                      GLenum matrixType, GLint location, GLsizei count,
1706                      GLboolean transpose, const GLfloat *values)
1707 {
1708    GLint offset;
1709    struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
1710
1711    if (!shProg || !shProg->LinkStatus) {
1712       _mesa_error(ctx, GL_INVALID_OPERATION,
1713          "glUniformMatrix(program not linked)");
1714       return;
1715    }
1716
1717    if (location == -1)
1718       return;   /* The standard specifies this as a no-op */
1719
1720    split_location_offset(&location, &offset);
1721
1722    if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
1723       _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(location)");
1724       return;
1725    }
1726    if (values == NULL) {
1727       _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");
1728       return;
1729    }
1730
1731    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1732
1733    if (shProg->VertexProgram) {
1734       /* convert uniform location to program parameter index */
1735       GLint index = shProg->Uniforms->Uniforms[location].VertPos;
1736       if (index >= 0) {
1737          set_program_uniform_matrix(ctx, &shProg->VertexProgram->Base,
1738                                     index, offset,
1739                                     count, rows, cols, transpose, values);
1740       }
1741    }
1742
1743    if (shProg->FragmentProgram) {
1744       /* convert uniform location to program parameter index */
1745       GLint index = shProg->Uniforms->Uniforms[location].FragPos;
1746       if (index >= 0) {
1747          set_program_uniform_matrix(ctx, &shProg->FragmentProgram->Base,
1748                                     index, offset,
1749                                     count, rows, cols, transpose, values);
1750       }
1751    }
1752 }
1753
1754
1755 static void
1756 _mesa_validate_program(GLcontext *ctx, GLuint program)
1757 {
1758    struct gl_shader_program *shProg;
1759
1760    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1761    if (!shProg) {
1762       return;
1763    }
1764
1765    if (!shProg->LinkStatus) {
1766       shProg->Validated = GL_FALSE;
1767       return;
1768    }
1769
1770    /* From the GL spec, a program is invalid if any of these are true:
1771
1772      any two active samplers in the current program object are of
1773      different types, but refer to the same texture image unit,
1774
1775      any active sampler in the current program object refers to a texture
1776      image unit where fixed-function fragment processing accesses a
1777      texture target that does not match the sampler type, or
1778
1779      the sum of the number of active samplers in the program and the
1780      number of texture image units enabled for fixed-function fragment
1781      processing exceeds the combined limit on the total number of texture
1782      image units allowed.
1783    */
1784
1785    shProg->Validated = GL_TRUE;
1786 }
1787
1788
1789 /**
1790  * Plug in Mesa's GLSL functions into the device driver function table.
1791  */
1792 void
1793 _mesa_init_glsl_driver_functions(struct dd_function_table *driver)
1794 {
1795    driver->AttachShader = _mesa_attach_shader;
1796    driver->BindAttribLocation = _mesa_bind_attrib_location;
1797    driver->CompileShader = _mesa_compile_shader;
1798    driver->CreateProgram = _mesa_create_program;
1799    driver->CreateShader = _mesa_create_shader;
1800    driver->DeleteProgram2 = _mesa_delete_program2;
1801    driver->DeleteShader = _mesa_delete_shader;
1802    driver->DetachShader = _mesa_detach_shader;
1803    driver->GetActiveAttrib = _mesa_get_active_attrib;
1804    driver->GetActiveUniform = _mesa_get_active_uniform;
1805    driver->GetAttachedShaders = _mesa_get_attached_shaders;
1806    driver->GetAttribLocation = _mesa_get_attrib_location;
1807    driver->GetHandle = _mesa_get_handle;
1808    driver->GetProgramiv = _mesa_get_programiv;
1809    driver->GetProgramInfoLog = _mesa_get_program_info_log;
1810    driver->GetShaderiv = _mesa_get_shaderiv;
1811    driver->GetShaderInfoLog = _mesa_get_shader_info_log;
1812    driver->GetShaderSource = _mesa_get_shader_source;
1813    driver->GetUniformfv = _mesa_get_uniformfv;
1814    driver->GetUniformiv = _mesa_get_uniformiv;
1815    driver->GetUniformLocation = _mesa_get_uniform_location;
1816    driver->IsProgram = _mesa_is_program;
1817    driver->IsShader = _mesa_is_shader;
1818    driver->LinkProgram = _mesa_link_program;
1819    driver->ShaderSource = _mesa_shader_source;
1820    driver->Uniform = _mesa_uniform;
1821    driver->UniformMatrix = _mesa_uniform_matrix;
1822    driver->UseProgram = _mesa_use_program;
1823    driver->ValidateProgram = _mesa_validate_program;
1824 }