src/mesa/main/uniforms.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
   6  * Copyright © 2010 Intel Corporation
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  22  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24  * OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 /**
  28  * \file uniforms.c
  29  * Functions related to GLSL uniform variables.
  30  * \author Brian Paul
  31  */
  32
  33 /**
  34  * XXX things to do:
  35  * 1. Check that the right error code is generated for all _mesa_error() calls.
  36  * 2. Insert FLUSH_VERTICES calls in various places
  37  */
  38
  39 #include "main/glheader.h"
  40 #include "main/context.h"
  41 #include "main/dispatch.h"
  42 #include "main/shaderapi.h"
  43 #include "main/shaderobj.h"
  44 #include "main/uniforms.h"
  45 #include "main/enums.h"
  46 #include "ir_uniform.h"
  47 #include "glsl_types.h"
  48 #include "program/program.h"
  49
  50 /**
  51  * Update the vertex/fragment program's TexturesUsed array.
  52  *
  53  * This needs to be called after glUniform(set sampler var) is called.
  54  * A call to glUniform(samplerVar, value) causes a sampler to point to a
  55  * particular texture unit.  We know the sampler's texture target
  56  * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
  57  * set by glUniform() calls.
  58  *
  59  * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
  60  * information to update the prog->TexturesUsed[] values.
  61  * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
  62  * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
  63  * We'll use that info for state validation before rendering.
  64  */
  65 void
  66 _mesa_update_shader_textures_used(struct gl_shader_program *shProg,
  67                                   struct gl_program *prog)
  68 {
  69    GLuint s;
  70    struct gl_shader *shader =
  71       shProg->_LinkedShaders[_mesa_program_enum_to_shader_stage(prog->Target)];
  72
  73    assert(shader);
  74
  75    memcpy(prog->SamplerUnits, shader->SamplerUnits, sizeof(prog->SamplerUnits));
  76    memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));
  77
  78    shProg->SamplersValidated = GL_TRUE;
  79
  80    for (s = 0; s < MAX_SAMPLERS; s++) {
  81       if (prog->SamplersUsed & (1 << s)) {
  82          GLuint unit = shader->SamplerUnits[s];
  83          GLuint tgt = shader->SamplerTargets[s];
  84          assert(unit < ARRAY_SIZE(prog->TexturesUsed));
  85          assert(tgt < NUM_TEXTURE_TARGETS);
  86
  87          /* The types of the samplers associated with a particular texture
  88           * unit must be an exact match.  Page 74 (page 89 of the PDF) of the
  89           * OpenGL 3.3 core spec says:
  90           *
  91           *     "It is not allowed to have variables of different sampler
  92           *     types pointing to the same texture image unit within a program
  93           *     object."
  94           */
  95          if (prog->TexturesUsed[unit] & ~(1 << tgt))
  96             shProg->SamplersValidated = GL_FALSE;
  97
  98          prog->TexturesUsed[unit] |= (1 << tgt);
  99       }
 100    }
 101 }
 102
 103 /**
 104  * Connect a piece of driver storage with a part of a uniform
 105  *
 106  * \param uni            The uniform with which the storage will be associated
 107  * \param element_stride Byte-stride between array elements.
 108  *                       \sa gl_uniform_driver_storage::element_stride.
 109  * \param vector_stride  Byte-stride between vectors (in a matrix).
 110  *                       \sa gl_uniform_driver_storage::vector_stride.
 111  * \param format         Conversion from native format to driver format
 112  *                       required by the driver.
 113  * \param data           Location to dump the data.
 114  */
 115 void
 116 _mesa_uniform_attach_driver_storage(struct gl_uniform_storage *uni,
 117                                     unsigned element_stride,
 118                                     unsigned vector_stride,
 119                                     enum gl_uniform_driver_format format,
 120                                     void *data)
 121 {
 122    uni->driver_storage =
 123       realloc(uni->driver_storage,
 124               sizeof(struct gl_uniform_driver_storage)
 125               * (uni->num_driver_storage + 1));
 126
 127    uni->driver_storage[uni->num_driver_storage].element_stride = element_stride;
 128    uni->driver_storage[uni->num_driver_storage].vector_stride = vector_stride;
 129    uni->driver_storage[uni->num_driver_storage].format = format;
 130    uni->driver_storage[uni->num_driver_storage].data = data;
 131
 132    uni->num_driver_storage++;
 133 }
 134
 135 /**
 136  * Sever all connections with all pieces of driver storage for all uniforms
 137  *
 138  * \warning
 139  * This function does \b not release any of the \c data pointers
 140  * previously passed in to \c _mesa_uniform_attach_driver_stoarge.
 141  */
 142 void
 143 _mesa_uniform_detach_all_driver_storage(struct gl_uniform_storage *uni)
 144 {
 145    free(uni->driver_storage);
 146    uni->driver_storage = NULL;
 147    uni->num_driver_storage = 0;
 148 }
 149
 150 void GLAPIENTRY
 151 _mesa_Uniform1f(GLint location, GLfloat v0)
 152 {
 153    GET_CURRENT_CONTEXT(ctx);
 154    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_FLOAT, 1);
 155 }
 156
 157 void GLAPIENTRY
 158 _mesa_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
 159 {
 160    GET_CURRENT_CONTEXT(ctx);
 161    GLfloat v[2];
 162    v[0] = v0;
 163    v[1] = v1;
 164    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_FLOAT, 2);
 165 }
 166
 167 void GLAPIENTRY
 168 _mesa_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 169 {
 170    GET_CURRENT_CONTEXT(ctx);
 171    GLfloat v[3];
 172    v[0] = v0;
 173    v[1] = v1;
 174    v[2] = v2;
 175    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_FLOAT, 3);
 176 }
 177
 178 void GLAPIENTRY
 179 _mesa_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
 180                    GLfloat v3)
 181 {
 182    GET_CURRENT_CONTEXT(ctx);
 183    GLfloat v[4];
 184    v[0] = v0;
 185    v[1] = v1;
 186    v[2] = v2;
 187    v[3] = v3;
 188    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_FLOAT, 4);
 189 }
 190
 191 void GLAPIENTRY
 192 _mesa_Uniform1i(GLint location, GLint v0)
 193 {
 194    GET_CURRENT_CONTEXT(ctx);
 195    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_INT, 1);
 196 }
 197
 198 void GLAPIENTRY
 199 _mesa_Uniform2i(GLint location, GLint v0, GLint v1)
 200 {
 201    GET_CURRENT_CONTEXT(ctx);
 202    GLint v[2];
 203    v[0] = v0;
 204    v[1] = v1;
 205    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_INT, 2);
 206 }
 207
 208 void GLAPIENTRY
 209 _mesa_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 210 {
 211    GET_CURRENT_CONTEXT(ctx);
 212    GLint v[3];
 213    v[0] = v0;
 214    v[1] = v1;
 215    v[2] = v2;
 216    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_INT, 3);
 217 }
 218
 219 void GLAPIENTRY
 220 _mesa_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 221 {
 222    GET_CURRENT_CONTEXT(ctx);
 223    GLint v[4];
 224    v[0] = v0;
 225    v[1] = v1;
 226    v[2] = v2;
 227    v[3] = v3;
 228    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_INT, 4);
 229 }
 230
 231 void GLAPIENTRY
 232 _mesa_Uniform1fv(GLint location, GLsizei count, const GLfloat * value)
 233 {
 234    GET_CURRENT_CONTEXT(ctx);
 235    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 1);
 236 }
 237
 238 void GLAPIENTRY
 239 _mesa_Uniform2fv(GLint location, GLsizei count, const GLfloat * value)
 240 {
 241    GET_CURRENT_CONTEXT(ctx);
 242    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 2);
 243 }
 244
 245 void GLAPIENTRY
 246 _mesa_Uniform3fv(GLint location, GLsizei count, const GLfloat * value)
 247 {
 248    GET_CURRENT_CONTEXT(ctx);
 249    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 3);
 250 }
 251
 252 void GLAPIENTRY
 253 _mesa_Uniform4fv(GLint location, GLsizei count, const GLfloat * value)
 254 {
 255    GET_CURRENT_CONTEXT(ctx);
 256    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_FLOAT, 4);
 257 }
 258
 259 void GLAPIENTRY
 260 _mesa_Uniform1iv(GLint location, GLsizei count, const GLint * value)
 261 {
 262    GET_CURRENT_CONTEXT(ctx);
 263    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 1);
 264 }
 265
 266 void GLAPIENTRY
 267 _mesa_Uniform2iv(GLint location, GLsizei count, const GLint * value)
 268 {
 269    GET_CURRENT_CONTEXT(ctx);
 270    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 2);
 271 }
 272
 273 void GLAPIENTRY
 274 _mesa_Uniform3iv(GLint location, GLsizei count, const GLint * value)
 275 {
 276    GET_CURRENT_CONTEXT(ctx);
 277    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 3);
 278 }
 279
 280 void GLAPIENTRY
 281 _mesa_Uniform4iv(GLint location, GLsizei count, const GLint * value)
 282 {
 283    GET_CURRENT_CONTEXT(ctx);
 284    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_INT, 4);
 285 }
 286
 287 /** Same as above with direct state access **/
 288 void GLAPIENTRY
 289 _mesa_ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 290 {
 291    GET_CURRENT_CONTEXT(ctx);
 292    struct gl_shader_program *shProg =
 293       _mesa_lookup_shader_program_err(ctx, program,
 294             "glProgramUniform1f");
 295    _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_FLOAT, 1);
 296 }
 297
 298 void GLAPIENTRY
 299 _mesa_ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 300 {
 301    GET_CURRENT_CONTEXT(ctx);
 302    GLfloat v[2];
 303    struct gl_shader_program *shProg;
 304    v[0] = v0;
 305    v[1] = v1;
 306    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2f");
 307    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_FLOAT, 2);
 308 }
 309
 310 void GLAPIENTRY
 311 _mesa_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1,
 312                        GLfloat v2)
 313 {
 314    GET_CURRENT_CONTEXT(ctx);
 315    GLfloat v[3];
 316    struct gl_shader_program *shProg;
 317    v[0] = v0;
 318    v[1] = v1;
 319    v[2] = v2;
 320    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3f");
 321    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_FLOAT, 3);
 322 }
 323
 324 void GLAPIENTRY
 325 _mesa_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1,
 326                        GLfloat v2, GLfloat v3)
 327 {
 328    GET_CURRENT_CONTEXT(ctx);
 329    GLfloat v[4];
 330    struct gl_shader_program *shProg;
 331    v[0] = v0;
 332    v[1] = v1;
 333    v[2] = v2;
 334    v[3] = v3;
 335    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4f");
 336    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_FLOAT, 4);
 337 }
 338
 339 void GLAPIENTRY
 340 _mesa_ProgramUniform1i(GLuint program, GLint location, GLint v0)
 341 {
 342    GET_CURRENT_CONTEXT(ctx);
 343    struct gl_shader_program *shProg =
 344       _mesa_lookup_shader_program_err(ctx, program,
 345             "glProgramUniform1i");
 346    _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_INT, 1);
 347 }
 348
 349 void GLAPIENTRY
 350 _mesa_ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 351 {
 352    GET_CURRENT_CONTEXT(ctx);
 353    GLint v[2];
 354    struct gl_shader_program *shProg;
 355    v[0] = v0;
 356    v[1] = v1;
 357    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2i");
 358    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_INT, 2);
 359 }
 360
 361 void GLAPIENTRY
 362 _mesa_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1,
 363                        GLint v2)
 364 {
 365    GET_CURRENT_CONTEXT(ctx);
 366    GLint v[3];
 367    struct gl_shader_program *shProg;
 368    v[0] = v0;
 369    v[1] = v1;
 370    v[2] = v2;
 371    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3i");
 372    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_INT, 3);
 373 }
 374
 375 void GLAPIENTRY
 376 _mesa_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1,
 377                        GLint v2, GLint v3)
 378 {
 379    GET_CURRENT_CONTEXT(ctx);
 380    GLint v[4];
 381    struct gl_shader_program *shProg;
 382    v[0] = v0;
 383    v[1] = v1;
 384    v[2] = v2;
 385    v[3] = v3;
 386    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4i");
 387    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_INT, 4);
 388 }
 389
 390 void GLAPIENTRY
 391 _mesa_ProgramUniform1fv(GLuint program, GLint location, GLsizei count,
 392                         const GLfloat * value)
 393 {
 394    GET_CURRENT_CONTEXT(ctx);
 395    struct gl_shader_program *shProg =
 396       _mesa_lookup_shader_program_err(ctx, program,
 397             "glProgramUniform1fv");
 398    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 1);
 399 }
 400
 401 void GLAPIENTRY
 402 _mesa_ProgramUniform2fv(GLuint program, GLint location, GLsizei count,
 403                         const GLfloat * value)
 404 {
 405    GET_CURRENT_CONTEXT(ctx);
 406    struct gl_shader_program *shProg =
 407       _mesa_lookup_shader_program_err(ctx, program,
 408             "glProgramUniform2fv");
 409    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 2);
 410 }
 411
 412 void GLAPIENTRY
 413 _mesa_ProgramUniform3fv(GLuint program, GLint location, GLsizei count,
 414                         const GLfloat * value)
 415 {
 416    GET_CURRENT_CONTEXT(ctx);
 417    struct gl_shader_program *shProg =
 418       _mesa_lookup_shader_program_err(ctx, program,
 419             "glProgramUniform3fv");
 420    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 3);
 421 }
 422
 423 void GLAPIENTRY
 424 _mesa_ProgramUniform4fv(GLuint program, GLint location, GLsizei count,
 425                         const GLfloat * value)
 426 {
 427    GET_CURRENT_CONTEXT(ctx);
 428    struct gl_shader_program *shProg =
 429       _mesa_lookup_shader_program_err(ctx, program,
 430             "glProgramUniform4fv");
 431    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_FLOAT, 4);
 432 }
 433
 434 void GLAPIENTRY
 435 _mesa_ProgramUniform1iv(GLuint program, GLint location, GLsizei count,
 436                         const GLint * value)
 437 {
 438    GET_CURRENT_CONTEXT(ctx);
 439    struct gl_shader_program *shProg =
 440       _mesa_lookup_shader_program_err(ctx, program,
 441             "glProgramUniform1iv");
 442    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 1);
 443 }
 444
 445 void GLAPIENTRY
 446 _mesa_ProgramUniform2iv(GLuint program, GLint location, GLsizei count,
 447                         const GLint * value)
 448 {
 449    GET_CURRENT_CONTEXT(ctx);
 450    struct gl_shader_program *shProg =
 451       _mesa_lookup_shader_program_err(ctx, program,
 452             "glProgramUniform2iv");
 453    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 2);
 454 }
 455
 456 void GLAPIENTRY
 457 _mesa_ProgramUniform3iv(GLuint program, GLint location, GLsizei count,
 458                         const GLint * value)
 459 {
 460    GET_CURRENT_CONTEXT(ctx);
 461    struct gl_shader_program *shProg =
 462       _mesa_lookup_shader_program_err(ctx, program,
 463             "glProgramUniform3iv");
 464    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 3);
 465 }
 466
 467 void GLAPIENTRY
 468 _mesa_ProgramUniform4iv(GLuint program, GLint location, GLsizei count,
 469                         const GLint * value)
 470 {
 471    GET_CURRENT_CONTEXT(ctx);
 472    struct gl_shader_program *shProg =
 473       _mesa_lookup_shader_program_err(ctx, program,
 474             "glProgramUniform4iv");
 475    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_INT, 4);
 476 }
 477
 478
 479 /** OpenGL 3.0 GLuint-valued functions **/
 480 void GLAPIENTRY
 481 _mesa_Uniform1ui(GLint location, GLuint v0)
 482 {
 483    GET_CURRENT_CONTEXT(ctx);
 484    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_UINT, 1);
 485 }
 486
 487 void GLAPIENTRY
 488 _mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1)
 489 {
 490    GET_CURRENT_CONTEXT(ctx);
 491    GLuint v[2];
 492    v[0] = v0;
 493    v[1] = v1;
 494    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_UINT, 2);
 495 }
 496
 497 void GLAPIENTRY
 498 _mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 499 {
 500    GET_CURRENT_CONTEXT(ctx);
 501    GLuint v[3];
 502    v[0] = v0;
 503    v[1] = v1;
 504    v[2] = v2;
 505    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_UINT, 3);
 506 }
 507
 508 void GLAPIENTRY
 509 _mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 510 {
 511    GET_CURRENT_CONTEXT(ctx);
 512    GLuint v[4];
 513    v[0] = v0;
 514    v[1] = v1;
 515    v[2] = v2;
 516    v[3] = v3;
 517    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_UINT, 4);
 518 }
 519
 520 void GLAPIENTRY
 521 _mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
 522 {
 523    GET_CURRENT_CONTEXT(ctx);
 524    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 1);
 525 }
 526
 527 void GLAPIENTRY
 528 _mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
 529 {
 530    GET_CURRENT_CONTEXT(ctx);
 531    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 2);
 532 }
 533
 534 void GLAPIENTRY
 535 _mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
 536 {
 537    GET_CURRENT_CONTEXT(ctx);
 538    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 3);
 539 }
 540
 541 void GLAPIENTRY
 542 _mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
 543 {
 544    GET_CURRENT_CONTEXT(ctx);
 545    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_UINT, 4);
 546 }
 547
 548
 549
 550 void GLAPIENTRY
 551 _mesa_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
 552                           const GLfloat * value)
 553 {
 554    GET_CURRENT_CONTEXT(ctx);
 555    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 556                         2, 2, location, count, transpose, value, GLSL_TYPE_FLOAT);
 557 }
 558
 559 void GLAPIENTRY
 560 _mesa_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
 561                           const GLfloat * value)
 562 {
 563    GET_CURRENT_CONTEXT(ctx);
 564    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 565                         3, 3, location, count, transpose, value, GLSL_TYPE_FLOAT);
 566 }
 567
 568 void GLAPIENTRY
 569 _mesa_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
 570                           const GLfloat * value)
 571 {
 572    GET_CURRENT_CONTEXT(ctx);
 573    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 574                         4, 4, location, count, transpose, value, GLSL_TYPE_FLOAT);
 575 }
 576
 577 /** Same as above with direct state access **/
 578
 579 void GLAPIENTRY
 580 _mesa_ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 581 {
 582    GET_CURRENT_CONTEXT(ctx);
 583    struct gl_shader_program *shProg =
 584       _mesa_lookup_shader_program_err(ctx, program,
 585             "glProgramUniform1ui");
 586    _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_UINT, 1);
 587 }
 588
 589 void GLAPIENTRY
 590 _mesa_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 591 {
 592    GET_CURRENT_CONTEXT(ctx);
 593    GLuint v[2];
 594    struct gl_shader_program *shProg;
 595    v[0] = v0;
 596    v[1] = v1;
 597    shProg = _mesa_lookup_shader_program_err(ctx, program,
 598                                             "glProgramUniform2ui");
 599    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 2);
 600 }
 601
 602 void GLAPIENTRY
 603 _mesa_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1,
 604                         GLuint v2)
 605 {
 606    GET_CURRENT_CONTEXT(ctx);
 607    GLuint v[3];
 608    struct gl_shader_program *shProg;
 609    v[0] = v0;
 610    v[1] = v1;
 611    v[2] = v2;
 612    shProg = _mesa_lookup_shader_program_err(ctx, program,
 613                                             "glProgramUniform3ui");
 614    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 3);
 615 }
 616
 617 void GLAPIENTRY
 618 _mesa_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1,
 619                         GLuint v2, GLuint v3)
 620 {
 621    GET_CURRENT_CONTEXT(ctx);
 622    GLuint v[4];
 623    struct gl_shader_program *shProg;
 624    v[0] = v0;
 625    v[1] = v1;
 626    v[2] = v2;
 627    v[3] = v3;
 628    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4ui");
 629    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 4);
 630 }
 631
 632 void GLAPIENTRY
 633 _mesa_ProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
 634                          const GLuint *value)
 635 {
 636    GET_CURRENT_CONTEXT(ctx);
 637    struct gl_shader_program *shProg =
 638       _mesa_lookup_shader_program_err(ctx, program,
 639             "glProgramUniform1uiv");
 640    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 1);
 641 }
 642
 643 void GLAPIENTRY
 644 _mesa_ProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
 645                          const GLuint *value)
 646 {
 647    GET_CURRENT_CONTEXT(ctx);
 648    struct gl_shader_program *shProg =
 649       _mesa_lookup_shader_program_err(ctx, program,
 650             "glProgramUniform2uiv");
 651    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 2);
 652 }
 653
 654 void GLAPIENTRY
 655 _mesa_ProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
 656                          const GLuint *value)
 657 {
 658    GET_CURRENT_CONTEXT(ctx);
 659    struct gl_shader_program *shProg =
 660       _mesa_lookup_shader_program_err(ctx, program,
 661             "glProgramUniform3uiv");
 662    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 3);
 663 }
 664
 665 void GLAPIENTRY
 666 _mesa_ProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
 667                          const GLuint *value)
 668 {
 669    GET_CURRENT_CONTEXT(ctx);
 670    struct gl_shader_program *shProg =
 671       _mesa_lookup_shader_program_err(ctx, program,
 672             "glProgramUniform4uiv");
 673    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 4);
 674 }
 675
 676
 677
 678 void GLAPIENTRY
 679 _mesa_ProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count,
 680                               GLboolean transpose, const GLfloat * value)
 681 {
 682    GET_CURRENT_CONTEXT(ctx);
 683    struct gl_shader_program *shProg =
 684       _mesa_lookup_shader_program_err(ctx, program,
 685             "glProgramUniformMatrix2fv");
 686    _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GLSL_TYPE_FLOAT);
 687 }
 688
 689 void GLAPIENTRY
 690 _mesa_ProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count,
 691                               GLboolean transpose, const GLfloat * value)
 692 {
 693    GET_CURRENT_CONTEXT(ctx);
 694    struct gl_shader_program *shProg =
 695       _mesa_lookup_shader_program_err(ctx, program,
 696             "glProgramUniformMatrix3fv");
 697    _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GLSL_TYPE_FLOAT);
 698 }
 699
 700 void GLAPIENTRY
 701 _mesa_ProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count,
 702                               GLboolean transpose, const GLfloat * value)
 703 {
 704    GET_CURRENT_CONTEXT(ctx);
 705    struct gl_shader_program *shProg =
 706       _mesa_lookup_shader_program_err(ctx, program,
 707             "glProgramUniformMatrix4fv");
 708    _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GLSL_TYPE_FLOAT);
 709 }
 710
 711
 712 /**
 713  * Non-square UniformMatrix are OpenGL 2.1
 714  */
 715 void GLAPIENTRY
 716 _mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
 717                          const GLfloat *value)
 718 {
 719    GET_CURRENT_CONTEXT(ctx);
 720    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 721                         2, 3, location, count, transpose, value, GLSL_TYPE_FLOAT);
 722 }
 723
 724 void GLAPIENTRY
 725 _mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
 726                          const GLfloat *value)
 727 {
 728    GET_CURRENT_CONTEXT(ctx);
 729    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 730                         3, 2, location, count, transpose, value, GLSL_TYPE_FLOAT);
 731 }
 732
 733 void GLAPIENTRY
 734 _mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
 735                          const GLfloat *value)
 736 {
 737    GET_CURRENT_CONTEXT(ctx);
 738    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 739                         2, 4, location, count, transpose, value, GLSL_TYPE_FLOAT);
 740 }
 741
 742 void GLAPIENTRY
 743 _mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
 744                          const GLfloat *value)
 745 {
 746    GET_CURRENT_CONTEXT(ctx);
 747    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 748                         4, 2, location, count, transpose, value, GLSL_TYPE_FLOAT);
 749 }
 750
 751 void GLAPIENTRY
 752 _mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
 753                          const GLfloat *value)
 754 {
 755    GET_CURRENT_CONTEXT(ctx);
 756    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 757                         3, 4, location, count, transpose, value, GLSL_TYPE_FLOAT);
 758 }
 759
 760 void GLAPIENTRY
 761 _mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
 762                          const GLfloat *value)
 763 {
 764    GET_CURRENT_CONTEXT(ctx);
 765    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
 766                         4, 3, location, count, transpose, value, GLSL_TYPE_FLOAT);
 767 }
 768
 769 /** Same as above with direct state access **/
 770
 771 void GLAPIENTRY
 772 _mesa_ProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count,
 773                                 GLboolean transpose, const GLfloat * value)
 774 {
 775    GET_CURRENT_CONTEXT(ctx);
 776    struct gl_shader_program *shProg =
 777       _mesa_lookup_shader_program_err(ctx, program,
 778             "glProgramUniformMatrix2x3fv");
 779    _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GLSL_TYPE_FLOAT);
 780 }
 781
 782 void GLAPIENTRY
 783 _mesa_ProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count,
 784                                 GLboolean transpose, const GLfloat * value)
 785 {
 786    GET_CURRENT_CONTEXT(ctx);
 787    struct gl_shader_program *shProg =
 788       _mesa_lookup_shader_program_err(ctx, program,
 789             "glProgramUniformMatrix3x2fv");
 790    _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GLSL_TYPE_FLOAT);
 791 }
 792
 793 void GLAPIENTRY
 794 _mesa_ProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count,
 795                                 GLboolean transpose, const GLfloat * value)
 796 {
 797    GET_CURRENT_CONTEXT(ctx);
 798    struct gl_shader_program *shProg =
 799       _mesa_lookup_shader_program_err(ctx, program,
 800             "glProgramUniformMatrix2x4fv");
 801    _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GLSL_TYPE_FLOAT);
 802 }
 803
 804 void GLAPIENTRY
 805 _mesa_ProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count,
 806                                 GLboolean transpose, const GLfloat * value)
 807 {
 808    GET_CURRENT_CONTEXT(ctx);
 809    struct gl_shader_program *shProg =
 810       _mesa_lookup_shader_program_err(ctx, program,
 811             "glProgramUniformMatrix4x2fv");
 812    _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GLSL_TYPE_FLOAT);
 813 }
 814
 815 void GLAPIENTRY
 816 _mesa_ProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count,
 817                                 GLboolean transpose, const GLfloat * value)
 818 {
 819    GET_CURRENT_CONTEXT(ctx);
 820    struct gl_shader_program *shProg =
 821       _mesa_lookup_shader_program_err(ctx, program,
 822             "glProgramUniformMatrix3x4fv");
 823    _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GLSL_TYPE_FLOAT);
 824 }
 825
 826 void GLAPIENTRY
 827 _mesa_ProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count,
 828                                 GLboolean transpose, const GLfloat * value)
 829 {
 830    GET_CURRENT_CONTEXT(ctx);
 831    struct gl_shader_program *shProg =
 832       _mesa_lookup_shader_program_err(ctx, program,
 833             "glProgramUniformMatrix4x3fv");
 834    _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GLSL_TYPE_FLOAT);
 835 }
 836
 837
 838 void GLAPIENTRY
 839 _mesa_GetnUniformfvARB(GLuint program, GLint location,
 840                        GLsizei bufSize, GLfloat *params)
 841 {
 842    GET_CURRENT_CONTEXT(ctx);
 843    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_FLOAT, params);
 844 }
 845
 846 void GLAPIENTRY
 847 _mesa_GetUniformfv(GLuint program, GLint location, GLfloat *params)
 848 {
 849    _mesa_GetnUniformfvARB(program, location, INT_MAX, params);
 850 }
 851
 852
 853 void GLAPIENTRY
 854 _mesa_GetnUniformivARB(GLuint program, GLint location,
 855                        GLsizei bufSize, GLint *params)
 856 {
 857    GET_CURRENT_CONTEXT(ctx);
 858    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT, params);
 859 }
 860
 861 void GLAPIENTRY
 862 _mesa_GetUniformiv(GLuint program, GLint location, GLint *params)
 863 {
 864    _mesa_GetnUniformivARB(program, location, INT_MAX, params);
 865 }
 866
 867
 868 /* GL3 */
 869 void GLAPIENTRY
 870 _mesa_GetnUniformuivARB(GLuint program, GLint location,
 871                         GLsizei bufSize, GLuint *params)
 872 {
 873    GET_CURRENT_CONTEXT(ctx);
 874    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT, params);
 875 }
 876
 877 void GLAPIENTRY
 878 _mesa_GetUniformuiv(GLuint program, GLint location, GLuint *params)
 879 {
 880    _mesa_GetnUniformuivARB(program, location, INT_MAX, params);
 881 }
 882
 883
 884 /* GL4 */
 885 void GLAPIENTRY
 886 _mesa_GetnUniformdvARB(GLuint program, GLint location,
 887                        GLsizei bufSize, GLdouble *params)
 888 {
 889    GET_CURRENT_CONTEXT(ctx);
 890
 891    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_DOUBLE, params);
 892 }
 893
 894 void GLAPIENTRY
 895 _mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params)
 896 {
 897    _mesa_GetnUniformdvARB(program, location, INT_MAX, params);
 898 }
 899
 900
 901 GLint GLAPIENTRY
 902 _mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name)
 903 {
 904    struct gl_shader_program *shProg;
 905
 906    GET_CURRENT_CONTEXT(ctx);
 907
 908    shProg = _mesa_lookup_shader_program_err(ctx, programObj,
 909                                             "glGetUniformLocation");
 910    if (!shProg)
 911       return -1;
 912
 913    /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says:
 914     *
 915     *     "If program has not been successfully linked, the error
 916     *     INVALID_OPERATION is generated."
 917     */
 918    if (shProg->LinkStatus == GL_FALSE) {
 919       _mesa_error(ctx, GL_INVALID_OPERATION,
 920                   "glGetUniformLocation(program not linked)");
 921       return -1;
 922    }
 923
 924    return _mesa_program_resource_location(shProg, GL_UNIFORM, name);
 925 }
 926
 927 GLuint GLAPIENTRY
 928 _mesa_GetUniformBlockIndex(GLuint program,
 929                            const GLchar *uniformBlockName)
 930 {
 931    GET_CURRENT_CONTEXT(ctx);
 932    struct gl_shader_program *shProg;
 933
 934    if (!ctx->Extensions.ARB_uniform_buffer_object) {
 935       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex");
 936       return GL_INVALID_INDEX;
 937    }
 938
 939    shProg = _mesa_lookup_shader_program_err(ctx, program,
 940                                             "glGetUniformBlockIndex");
 941    if (!shProg)
 942       return GL_INVALID_INDEX;
 943
 944    struct gl_program_resource *res =
 945       _mesa_program_resource_find_name(shProg, GL_UNIFORM_BLOCK,
 946                                        uniformBlockName, NULL);
 947    if (!res)
 948       return GL_INVALID_INDEX;
 949
 950    return _mesa_program_resource_index(shProg, res);
 951 }
 952
 953 void GLAPIENTRY
 954 _mesa_GetUniformIndices(GLuint program,
 955                         GLsizei uniformCount,
 956                         const GLchar * const *uniformNames,
 957                         GLuint *uniformIndices)
 958 {
 959    GET_CURRENT_CONTEXT(ctx);
 960    GLsizei i;
 961    struct gl_shader_program *shProg;
 962
 963    if (!ctx->Extensions.ARB_uniform_buffer_object) {
 964       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices");
 965       return;
 966    }
 967
 968    shProg = _mesa_lookup_shader_program_err(ctx, program,
 969                                             "glGetUniformIndices");
 970    if (!shProg)
 971       return;
 972
 973    if (uniformCount < 0) {
 974       _mesa_error(ctx, GL_INVALID_VALUE,
 975                   "glGetUniformIndices(uniformCount < 0)");
 976       return;
 977    }
 978
 979    for (i = 0; i < uniformCount; i++) {
 980       struct gl_program_resource *res =
 981          _mesa_program_resource_find_name(shProg, GL_UNIFORM, uniformNames[i],
 982                                           NULL);
 983       uniformIndices[i] = _mesa_program_resource_index(shProg, res);
 984    }
 985 }
 986
 987 void GLAPIENTRY
 988 _mesa_UniformBlockBinding(GLuint program,
 989                           GLuint uniformBlockIndex,
 990                           GLuint uniformBlockBinding)
 991 {
 992    GET_CURRENT_CONTEXT(ctx);
 993    struct gl_shader_program *shProg;
 994
 995    if (!ctx->Extensions.ARB_uniform_buffer_object) {
 996       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding");
 997       return;
 998    }
 999
1000    shProg = _mesa_lookup_shader_program_err(ctx, program,
1001                                             "glUniformBlockBinding");
1002    if (!shProg)
1003       return;
1004
1005    if (uniformBlockIndex >= shProg->NumBufferInterfaceBlocks) {
1006       _mesa_error(ctx, GL_INVALID_VALUE,
1007                   "glUniformBlockBinding(block index %u >= %u)",
1008                   uniformBlockIndex, shProg->NumBufferInterfaceBlocks);
1009       return;
1010    }
1011
1012    if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) {
1013       _mesa_error(ctx, GL_INVALID_VALUE,
1014                   "glUniformBlockBinding(block binding %u >= %u)",
1015                   uniformBlockBinding, ctx->Const.MaxUniformBufferBindings);
1016       return;
1017    }
1018
1019    if (shProg->BufferInterfaceBlocks[uniformBlockIndex].Binding !=
1020        uniformBlockBinding) {
1021       int i;
1022
1023       FLUSH_VERTICES(ctx, 0);
1024       ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
1025
1026       shProg->BufferInterfaceBlocks[uniformBlockIndex].Binding = uniformBlockBinding;
1027
1028       for (i = 0; i < MESA_SHADER_STAGES; i++) {
1029          int stage_index = shProg->InterfaceBlockStageIndex[i][uniformBlockIndex];
1030
1031          if (stage_index != -1) {
1032             struct gl_shader *sh = shProg->_LinkedShaders[i];
1033             sh->BufferInterfaceBlocks[stage_index].Binding = uniformBlockBinding;
1034          }
1035       }
1036    }
1037 }
1038
1039 void GLAPIENTRY
1040 _mesa_ShaderStorageBlockBinding(GLuint program,
1041                                 GLuint shaderStorageBlockIndex,
1042                                 GLuint shaderStorageBlockBinding)
1043 {
1044    GET_CURRENT_CONTEXT(ctx);
1045    struct gl_shader_program *shProg;
1046
1047    if (!ctx->Extensions.ARB_shader_storage_buffer_object) {
1048       _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderStorageBlockBinding");
1049       return;
1050    }
1051
1052    shProg = _mesa_lookup_shader_program_err(ctx, program,
1053                                             "glShaderStorageBlockBinding");
1054    if (!shProg)
1055       return;
1056
1057    if (shaderStorageBlockIndex >= shProg->NumBufferInterfaceBlocks) {
1058       _mesa_error(ctx, GL_INVALID_VALUE,
1059                   "glShaderStorageBlockBinding(block index %u >= %u)",
1060                   shaderStorageBlockIndex, shProg->NumBufferInterfaceBlocks);
1061       return;
1062    }
1063
1064    if (shaderStorageBlockBinding >= ctx->Const.MaxShaderStorageBufferBindings) {
1065       _mesa_error(ctx, GL_INVALID_VALUE,
1066                   "glShaderStorageBlockBinding(block binding %u >= %u)",
1067                   shaderStorageBlockBinding,
1068                   ctx->Const.MaxShaderStorageBufferBindings);
1069       return;
1070    }
1071
1072    if (shProg->BufferInterfaceBlocks[shaderStorageBlockIndex].Binding !=
1073        shaderStorageBlockBinding) {
1074       int i;
1075
1076       FLUSH_VERTICES(ctx, 0);
1077       ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer;
1078
1079       shProg->BufferInterfaceBlocks[shaderStorageBlockIndex].Binding = shaderStorageBlockBinding;
1080
1081       for (i = 0; i < MESA_SHADER_STAGES; i++) {
1082          int stage_index = shProg->InterfaceBlockStageIndex[i][shaderStorageBlockIndex];
1083
1084          if (stage_index != -1) {
1085             struct gl_shader *sh = shProg->_LinkedShaders[i];
1086             sh->BufferInterfaceBlocks[stage_index].Binding = shaderStorageBlockBinding;
1087          }
1088       }
1089    }
1090 }
1091
1092 /**
1093  * Generic program resource property query.
1094  */
1095 static void
1096 mesa_bufferiv(struct gl_shader_program *shProg, GLenum type,
1097               GLuint index, GLenum pname, GLint *params, const char *caller)
1098 {
1099    GET_CURRENT_CONTEXT(ctx);
1100    struct gl_program_resource *res =
1101       _mesa_program_resource_find_index(shProg, type, index);
1102
1103    if (!res) {
1104       _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index);
1105       return;
1106    }
1107
1108    switch (pname) {
1109    case GL_UNIFORM_BLOCK_BINDING:
1110    case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1111       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING,
1112                                   params, caller);
1113       return;
1114    case GL_UNIFORM_BLOCK_DATA_SIZE:
1115    case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
1116       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE,
1117                                   params, caller);
1118       return;
1119    case GL_UNIFORM_BLOCK_NAME_LENGTH:
1120       _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH,
1121                                   params, caller);
1122       return;
1123    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
1124    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
1125       _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES,
1126                                   params, caller);
1127       return;
1128    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
1129    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
1130       _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES,
1131                                   params, caller);
1132       return;
1133    case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
1134    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
1135       _mesa_program_resource_prop(shProg, res, index,
1136                                   GL_REFERENCED_BY_VERTEX_SHADER, params,
1137                                   caller);
1138       return;
1139
1140    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER:
1141    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
1142       _mesa_program_resource_prop(shProg, res, index,
1143                                   GL_REFERENCED_BY_TESS_CONTROL_SHADER, params,
1144                                   caller);
1145       return;
1146
1147    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER:
1148    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
1149       _mesa_program_resource_prop(shProg, res, index,
1150                                   GL_REFERENCED_BY_TESS_EVALUATION_SHADER, params,
1151                                   caller);
1152       return;
1153
1154    case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
1155    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
1156       _mesa_program_resource_prop(shProg, res, index,
1157                                   GL_REFERENCED_BY_GEOMETRY_SHADER, params,
1158                                   caller);
1159       return;
1160    case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
1161    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
1162       _mesa_program_resource_prop(shProg, res, index,
1163                                   GL_REFERENCED_BY_FRAGMENT_SHADER, params,
1164                                   caller);
1165       return;
1166    default:
1167       _mesa_error(ctx, GL_INVALID_ENUM,
1168                   "%s(pname 0x%x (%s))", caller, pname,
1169                   _mesa_enum_to_string(pname));
1170       return;
1171    }
1172 }
1173
1174
1175 void GLAPIENTRY
1176 _mesa_GetActiveUniformBlockiv(GLuint program,
1177                               GLuint uniformBlockIndex,
1178                               GLenum pname,
1179                               GLint *params)
1180 {
1181    GET_CURRENT_CONTEXT(ctx);
1182    struct gl_shader_program *shProg;
1183
1184    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1185       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1186       return;
1187    }
1188
1189    shProg = _mesa_lookup_shader_program_err(ctx, program,
1190                                             "glGetActiveUniformBlockiv");
1191    if (!shProg)
1192       return;
1193
1194    mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params,
1195                  "glGetActiveUniformBlockiv");
1196 }
1197
1198 void GLAPIENTRY
1199 _mesa_GetActiveUniformBlockName(GLuint program,
1200                                 GLuint uniformBlockIndex,
1201                                 GLsizei bufSize,
1202                                 GLsizei *length,
1203                                 GLchar *uniformBlockName)
1204 {
1205    GET_CURRENT_CONTEXT(ctx);
1206    struct gl_shader_program *shProg;
1207
1208    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1209       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1210       return;
1211    }
1212
1213    if (bufSize < 0) {
1214       _mesa_error(ctx, GL_INVALID_VALUE,
1215                   "glGetActiveUniformBlockName(bufSize %d < 0)",
1216                   bufSize);
1217       return;
1218    }
1219
1220    shProg = _mesa_lookup_shader_program_err(ctx, program,
1221                                             "glGetActiveUniformBlockiv");
1222    if (!shProg)
1223       return;
1224
1225    if (uniformBlockName)
1226       _mesa_get_program_resource_name(shProg, GL_UNIFORM_BLOCK,
1227                                       uniformBlockIndex, bufSize, length,
1228                                       uniformBlockName,
1229                                       "glGetActiveUniformBlockName");
1230 }
1231
1232 void GLAPIENTRY
1233 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex,
1234                            GLsizei bufSize, GLsizei *length,
1235                            GLchar *uniformName)
1236 {
1237    GET_CURRENT_CONTEXT(ctx);
1238    struct gl_shader_program *shProg;
1239
1240    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1241       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName");
1242       return;
1243    }
1244
1245    if (bufSize < 0) {
1246       _mesa_error(ctx, GL_INVALID_VALUE,
1247                   "glGetActiveUniformName(bufSize %d < 0)",
1248                   bufSize);
1249       return;
1250    }
1251
1252    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName");
1253
1254    if (!shProg)
1255       return;
1256
1257    _mesa_get_program_resource_name(shProg, GL_UNIFORM, uniformIndex, bufSize,
1258                                    length, uniformName, "glGetActiveUniformName");
1259 }
1260
1261 void GLAPIENTRY
1262 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex,
1263                                      GLenum pname, GLint *params)
1264 {
1265    GET_CURRENT_CONTEXT(ctx);
1266    struct gl_shader_program *shProg;
1267
1268    if (!ctx->Extensions.ARB_shader_atomic_counters) {
1269       _mesa_error(ctx, GL_INVALID_OPERATION,
1270                   "glGetActiveAtomicCounterBufferiv");
1271       return;
1272    }
1273
1274    shProg = _mesa_lookup_shader_program_err(ctx, program,
1275                                             "glGetActiveAtomicCounterBufferiv");
1276    if (!shProg)
1277       return;
1278
1279    mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params,
1280                  "glGetActiveAtomicCounterBufferiv");
1281 }
1282
1283 void GLAPIENTRY
1284 _mesa_Uniform1d(GLint location, GLdouble v0)
1285 {
1286    GET_CURRENT_CONTEXT(ctx);
1287    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1288 }
1289
1290 void GLAPIENTRY
1291 _mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1)
1292 {
1293    GET_CURRENT_CONTEXT(ctx);
1294    GLdouble v[2];
1295    v[0] = v0;
1296    v[1] = v1;
1297    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1298 }
1299
1300 void GLAPIENTRY
1301 _mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
1302 {
1303    GET_CURRENT_CONTEXT(ctx);
1304    GLdouble v[3];
1305    v[0] = v0;
1306    v[1] = v1;
1307    v[2] = v2;
1308    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1309 }
1310
1311 void GLAPIENTRY
1312 _mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2,
1313                 GLdouble v3)
1314 {
1315    GET_CURRENT_CONTEXT(ctx);
1316    GLdouble v[4];
1317    v[0] = v0;
1318    v[1] = v1;
1319    v[2] = v2;
1320    v[3] = v3;
1321    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1322 }
1323
1324 void GLAPIENTRY
1325 _mesa_Uniform1dv(GLint location, GLsizei count, const GLdouble * value)
1326 {
1327    GET_CURRENT_CONTEXT(ctx);
1328    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 1);
1329 }
1330
1331 void GLAPIENTRY
1332 _mesa_Uniform2dv(GLint location, GLsizei count, const GLdouble * value)
1333 {
1334    GET_CURRENT_CONTEXT(ctx);
1335    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 2);
1336 }
1337
1338 void GLAPIENTRY
1339 _mesa_Uniform3dv(GLint location, GLsizei count, const GLdouble * value)
1340 {
1341    GET_CURRENT_CONTEXT(ctx);
1342    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 3);
1343 }
1344
1345 void GLAPIENTRY
1346 _mesa_Uniform4dv(GLint location, GLsizei count, const GLdouble * value)
1347 {
1348    GET_CURRENT_CONTEXT(ctx);
1349    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 4);
1350 }
1351
1352 void GLAPIENTRY
1353 _mesa_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,
1354                        const GLdouble * value)
1355 {
1356    GET_CURRENT_CONTEXT(ctx);
1357    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1358                         2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1359 }
1360
1361 void GLAPIENTRY
1362 _mesa_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,
1363                        const GLdouble * value)
1364 {
1365    GET_CURRENT_CONTEXT(ctx);
1366    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1367                         3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1368 }
1369
1370 void GLAPIENTRY
1371 _mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
1372                        const GLdouble * value)
1373 {
1374    GET_CURRENT_CONTEXT(ctx);
1375    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1376                         4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1377 }
1378
1379 void GLAPIENTRY
1380 _mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
1381                          const GLdouble *value)
1382 {
1383    GET_CURRENT_CONTEXT(ctx);
1384    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1385                         2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1386 }
1387
1388 void GLAPIENTRY
1389 _mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
1390                          const GLdouble *value)
1391 {
1392    GET_CURRENT_CONTEXT(ctx);
1393    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1394                         3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1395 }
1396
1397 void GLAPIENTRY
1398 _mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
1399                          const GLdouble *value)
1400 {
1401    GET_CURRENT_CONTEXT(ctx);
1402    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1403                         2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1404 }
1405
1406 void GLAPIENTRY
1407 _mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
1408                          const GLdouble *value)
1409 {
1410    GET_CURRENT_CONTEXT(ctx);
1411    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1412                         4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1413 }
1414
1415 void GLAPIENTRY
1416 _mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
1417                          const GLdouble *value)
1418 {
1419    GET_CURRENT_CONTEXT(ctx);
1420    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1421                         3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1422 }
1423
1424 void GLAPIENTRY
1425 _mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
1426                          const GLdouble *value)
1427 {
1428    GET_CURRENT_CONTEXT(ctx);
1429    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1430                         4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1431 }
1432
1433 void GLAPIENTRY
1434 _mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0)
1435 {
1436    GET_CURRENT_CONTEXT(ctx);
1437    struct gl_shader_program *shProg =
1438       _mesa_lookup_shader_program_err(ctx, program,
1439             "glProgramUniform1d");
1440    _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1441 }
1442
1443 void GLAPIENTRY
1444 _mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
1445 {
1446    GET_CURRENT_CONTEXT(ctx);
1447    GLdouble v[2];
1448    struct gl_shader_program *shProg;
1449    v[0] = v0;
1450    v[1] = v1;
1451    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d");
1452    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1453 }
1454
1455 void GLAPIENTRY
1456 _mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1457                        GLdouble v2)
1458 {
1459    GET_CURRENT_CONTEXT(ctx);
1460    GLdouble v[3];
1461    struct gl_shader_program *shProg;
1462    v[0] = v0;
1463    v[1] = v1;
1464    v[2] = v2;
1465    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d");
1466    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1467 }
1468
1469 void GLAPIENTRY
1470 _mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1471                        GLdouble v2, GLdouble v3)
1472 {
1473    GET_CURRENT_CONTEXT(ctx);
1474    GLdouble v[4];
1475    struct gl_shader_program *shProg;
1476    v[0] = v0;
1477    v[1] = v1;
1478    v[2] = v2;
1479    v[3] = v3;
1480    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d");
1481    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1482 }
1483
1484 void GLAPIENTRY
1485 _mesa_ProgramUniform1dv(GLuint program, GLint location, GLsizei count,
1486                         const GLdouble * value)
1487 {
1488    GET_CURRENT_CONTEXT(ctx);
1489    struct gl_shader_program *shProg =
1490       _mesa_lookup_shader_program_err(ctx, program,
1491             "glProgramUniform1dv");
1492    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 1);
1493 }
1494
1495 void GLAPIENTRY
1496 _mesa_ProgramUniform2dv(GLuint program, GLint location, GLsizei count,
1497                         const GLdouble * value)
1498 {
1499    GET_CURRENT_CONTEXT(ctx);
1500    struct gl_shader_program *shProg =
1501       _mesa_lookup_shader_program_err(ctx, program,
1502             "glProgramUniform2dv");
1503    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 2);
1504 }
1505
1506 void GLAPIENTRY
1507 _mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count,
1508                         const GLdouble * value)
1509 {
1510    GET_CURRENT_CONTEXT(ctx);
1511    struct gl_shader_program *shProg =
1512       _mesa_lookup_shader_program_err(ctx, program,
1513             "glProgramUniform3dv");
1514    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 3);
1515 }
1516
1517 void GLAPIENTRY
1518 _mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count,
1519                         const GLdouble * value)
1520 {
1521    GET_CURRENT_CONTEXT(ctx);
1522    struct gl_shader_program *shProg =
1523       _mesa_lookup_shader_program_err(ctx, program,
1524             "glProgramUniform4dv");
1525    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 4);
1526 }
1527
1528 void GLAPIENTRY
1529 _mesa_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count,
1530                               GLboolean transpose, const GLdouble * value)
1531 {
1532    GET_CURRENT_CONTEXT(ctx);
1533    struct gl_shader_program *shProg =
1534       _mesa_lookup_shader_program_err(ctx, program,
1535             "glProgramUniformMatrix2dv");
1536    _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1537 }
1538
1539 void GLAPIENTRY
1540 _mesa_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count,
1541                               GLboolean transpose, const GLdouble * value)
1542 {
1543    GET_CURRENT_CONTEXT(ctx);
1544    struct gl_shader_program *shProg =
1545       _mesa_lookup_shader_program_err(ctx, program,
1546             "glProgramUniformMatrix3dv");
1547    _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1548 }
1549
1550 void GLAPIENTRY
1551 _mesa_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count,
1552                               GLboolean transpose, const GLdouble * value)
1553 {
1554    GET_CURRENT_CONTEXT(ctx);
1555    struct gl_shader_program *shProg =
1556       _mesa_lookup_shader_program_err(ctx, program,
1557             "glProgramUniformMatrix4dv");
1558    _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1559 }
1560
1561 void GLAPIENTRY
1562 _mesa_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count,
1563                                 GLboolean transpose, const GLdouble * value)
1564 {
1565    GET_CURRENT_CONTEXT(ctx);
1566    struct gl_shader_program *shProg =
1567       _mesa_lookup_shader_program_err(ctx, program,
1568             "glProgramUniformMatrix2x3dv");
1569    _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1570 }
1571
1572 void GLAPIENTRY
1573 _mesa_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count,
1574                                 GLboolean transpose, const GLdouble * value)
1575 {
1576    GET_CURRENT_CONTEXT(ctx);
1577    struct gl_shader_program *shProg =
1578       _mesa_lookup_shader_program_err(ctx, program,
1579             "glProgramUniformMatrix3x2dv");
1580    _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1581 }
1582
1583 void GLAPIENTRY
1584 _mesa_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count,
1585                                 GLboolean transpose, const GLdouble * value)
1586 {
1587    GET_CURRENT_CONTEXT(ctx);
1588    struct gl_shader_program *shProg =
1589       _mesa_lookup_shader_program_err(ctx, program,
1590             "glProgramUniformMatrix2x4dv");
1591    _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1592 }
1593
1594 void GLAPIENTRY
1595 _mesa_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count,
1596                                 GLboolean transpose, const GLdouble * value)
1597 {
1598    GET_CURRENT_CONTEXT(ctx);
1599    struct gl_shader_program *shProg =
1600       _mesa_lookup_shader_program_err(ctx, program,
1601             "glProgramUniformMatrix4x2dv");
1602    _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1603 }
1604
1605 void GLAPIENTRY
1606 _mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count,
1607                                 GLboolean transpose, const GLdouble * value)
1608 {
1609    GET_CURRENT_CONTEXT(ctx);
1610    struct gl_shader_program *shProg =
1611       _mesa_lookup_shader_program_err(ctx, program,
1612             "glProgramUniformMatrix3x4dv");
1613    _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1614 }
1615
1616 void GLAPIENTRY
1617 _mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count,
1618                                 GLboolean transpose, const GLdouble * value)
1619 {
1620    GET_CURRENT_CONTEXT(ctx);
1621    struct gl_shader_program *shProg =
1622       _mesa_lookup_shader_program_err(ctx, program,
1623             "glProgramUniformMatrix4x3dv");
1624    _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1625 }