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 "compiler/glsl/ir_uniform.h"
  47 #include "compiler/glsl_types.h"
  48 #include "program/program.h"
  49 #include "util/bitscan.h"
  50
  51 /**
  52  * Update the vertex/fragment program's TexturesUsed array.
  53  *
  54  * This needs to be called after glUniform(set sampler var) is called.
  55  * A call to glUniform(samplerVar, value) causes a sampler to point to a
  56  * particular texture unit.  We know the sampler's texture target
  57  * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
  58  * set by glUniform() calls.
  59  *
  60  * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
  61  * information to update the prog->TexturesUsed[] values.
  62  * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
  63  * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
  64  * We'll use that info for state validation before rendering.
  65  */
  66 static inline void
  67 update_single_shader_texture_used(struct gl_shader_program *shProg,
  68                                   struct gl_program *prog,
  69                                   GLuint unit, GLuint target)
  70 {
  71    gl_shader_stage prog_stage =
  72       _mesa_program_enum_to_shader_stage(prog->Target);
  73
  74    assert(unit < ARRAY_SIZE(prog->TexturesUsed));
  75    assert(target < NUM_TEXTURE_TARGETS);
  76
  77    /* From section 7.10 (Samplers) of the OpenGL 4.5 spec:
  78     *
  79     * "It is not allowed to have variables of different sampler types pointing
  80     *  to the same texture image unit within a program object."
  81     */
  82    unsigned stages_mask = shProg->data->linked_stages;
  83    while (stages_mask) {
  84       const int stage = u_bit_scan(&stages_mask);
  85
  86       /* Skip validation if we are yet to update textures used in this
  87        * stage.
  88        */
  89       if (prog_stage < stage)
  90          break;
  91
  92       struct gl_program *glprog = shProg->_LinkedShaders[stage]->Program;
  93       if (glprog->TexturesUsed[unit] & ~(1 << target))
  94          shProg->SamplersValidated = GL_FALSE;
  95    }
  96
  97    prog->TexturesUsed[unit] |= (1 << target);
  98 }
  99
 100 void
 101 _mesa_update_shader_textures_used(struct gl_shader_program *shProg,
 102                                   struct gl_program *prog)
 103 {
 104    GLbitfield mask = prog->SamplersUsed;
 105    gl_shader_stage prog_stage =
 106       _mesa_program_enum_to_shader_stage(prog->Target);
 107    MAYBE_UNUSED struct gl_linked_shader *shader =
 108       shProg->_LinkedShaders[prog_stage];
 109    GLuint s;
 110
 111    assert(shader);
 112
 113    memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));
 114
 115    while (mask) {
 116       s = u_bit_scan(&mask);
 117
 118       update_single_shader_texture_used(shProg, prog,
 119                                         prog->SamplerUnits[s],
 120                                         prog->sh.SamplerTargets[s]);
 121    }
 122
 123    if (unlikely(prog->sh.HasBoundBindlessSampler)) {
 124       /* Loop over bindless samplers bound to texture units.
 125        */
 126       for (s = 0; s < prog->sh.NumBindlessSamplers; s++) {
 127          struct gl_bindless_sampler *sampler = &prog->sh.BindlessSamplers[s];
 128
 129          if (!sampler->bound)
 130             continue;
 131
 132          update_single_shader_texture_used(shProg, prog, sampler->unit,
 133                                            sampler->target);
 134       }
 135    }
 136 }
 137
 138 /**
 139  * Connect a piece of driver storage with a part of a uniform
 140  *
 141  * \param uni            The uniform with which the storage will be associated
 142  * \param element_stride Byte-stride between array elements.
 143  *                       \sa gl_uniform_driver_storage::element_stride.
 144  * \param vector_stride  Byte-stride between vectors (in a matrix).
 145  *                       \sa gl_uniform_driver_storage::vector_stride.
 146  * \param format         Conversion from native format to driver format
 147  *                       required by the driver.
 148  * \param data           Location to dump the data.
 149  */
 150 void
 151 _mesa_uniform_attach_driver_storage(struct gl_uniform_storage *uni,
 152                                     unsigned element_stride,
 153                                     unsigned vector_stride,
 154                                     enum gl_uniform_driver_format format,
 155                                     void *data)
 156 {
 157    uni->driver_storage =
 158       realloc(uni->driver_storage,
 159               sizeof(struct gl_uniform_driver_storage)
 160               * (uni->num_driver_storage + 1));
 161
 162    uni->driver_storage[uni->num_driver_storage].element_stride = element_stride;
 163    uni->driver_storage[uni->num_driver_storage].vector_stride = vector_stride;
 164    uni->driver_storage[uni->num_driver_storage].format = format;
 165    uni->driver_storage[uni->num_driver_storage].data = data;
 166
 167    uni->num_driver_storage++;
 168 }
 169
 170 /**
 171  * Sever all connections with all pieces of driver storage for all uniforms
 172  *
 173  * \warning
 174  * This function does \b not release any of the \c data pointers
 175  * previously passed in to \c _mesa_uniform_attach_driver_stoarge.
 176  */
 177 void
 178 _mesa_uniform_detach_all_driver_storage(struct gl_uniform_storage *uni)
 179 {
 180    free(uni->driver_storage);
 181    uni->driver_storage = NULL;
 182    uni->num_driver_storage = 0;
 183 }
 184
 185 void GLAPIENTRY
 186 _mesa_Uniform1f(GLint location, GLfloat v0)
 187 {
 188    GET_CURRENT_CONTEXT(ctx);
 189    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 1);
 190 }
 191
 192 void GLAPIENTRY
 193 _mesa_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
 194 {
 195    GET_CURRENT_CONTEXT(ctx);
 196    GLfloat v[2];
 197    v[0] = v0;
 198    v[1] = v1;
 199    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 2);
 200 }
 201
 202 void GLAPIENTRY
 203 _mesa_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 204 {
 205    GET_CURRENT_CONTEXT(ctx);
 206    GLfloat v[3];
 207    v[0] = v0;
 208    v[1] = v1;
 209    v[2] = v2;
 210    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 3);
 211 }
 212
 213 void GLAPIENTRY
 214 _mesa_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
 215                    GLfloat v3)
 216 {
 217    GET_CURRENT_CONTEXT(ctx);
 218    GLfloat v[4];
 219    v[0] = v0;
 220    v[1] = v1;
 221    v[2] = v2;
 222    v[3] = v3;
 223    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 4);
 224 }
 225
 226 void GLAPIENTRY
 227 _mesa_Uniform1i(GLint location, GLint v0)
 228 {
 229    GET_CURRENT_CONTEXT(ctx);
 230    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 1);
 231 }
 232
 233 void GLAPIENTRY
 234 _mesa_Uniform2i(GLint location, GLint v0, GLint v1)
 235 {
 236    GET_CURRENT_CONTEXT(ctx);
 237    GLint v[2];
 238    v[0] = v0;
 239    v[1] = v1;
 240    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 2);
 241 }
 242
 243 void GLAPIENTRY
 244 _mesa_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 245 {
 246    GET_CURRENT_CONTEXT(ctx);
 247    GLint v[3];
 248    v[0] = v0;
 249    v[1] = v1;
 250    v[2] = v2;
 251    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 3);
 252 }
 253
 254 void GLAPIENTRY
 255 _mesa_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 256 {
 257    GET_CURRENT_CONTEXT(ctx);
 258    GLint v[4];
 259    v[0] = v0;
 260    v[1] = v1;
 261    v[2] = v2;
 262    v[3] = v3;
 263    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 4);
 264 }
 265
 266 void GLAPIENTRY
 267 _mesa_Uniform1fv(GLint location, GLsizei count, const GLfloat * value)
 268 {
 269    GET_CURRENT_CONTEXT(ctx);
 270    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 1);
 271 }
 272
 273 void GLAPIENTRY
 274 _mesa_Uniform2fv(GLint location, GLsizei count, const GLfloat * value)
 275 {
 276    GET_CURRENT_CONTEXT(ctx);
 277    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 2);
 278 }
 279
 280 void GLAPIENTRY
 281 _mesa_Uniform3fv(GLint location, GLsizei count, const GLfloat * value)
 282 {
 283    GET_CURRENT_CONTEXT(ctx);
 284    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 3);
 285 }
 286
 287 void GLAPIENTRY
 288 _mesa_Uniform4fv(GLint location, GLsizei count, const GLfloat * value)
 289 {
 290    GET_CURRENT_CONTEXT(ctx);
 291    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 4);
 292 }
 293
 294 void GLAPIENTRY
 295 _mesa_Uniform1iv(GLint location, GLsizei count, const GLint * value)
 296 {
 297    GET_CURRENT_CONTEXT(ctx);
 298    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 1);
 299 }
 300
 301 void GLAPIENTRY
 302 _mesa_Uniform2iv(GLint location, GLsizei count, const GLint * value)
 303 {
 304    GET_CURRENT_CONTEXT(ctx);
 305    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 2);
 306 }
 307
 308 void GLAPIENTRY
 309 _mesa_Uniform3iv(GLint location, GLsizei count, const GLint * value)
 310 {
 311    GET_CURRENT_CONTEXT(ctx);
 312    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 3);
 313 }
 314
 315 void GLAPIENTRY
 316 _mesa_Uniform4iv(GLint location, GLsizei count, const GLint * value)
 317 {
 318    GET_CURRENT_CONTEXT(ctx);
 319    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 4);
 320 }
 321
 322 void GLAPIENTRY
 323 _mesa_UniformHandleui64ARB(GLint location, GLuint64 value)
 324 {
 325    GET_CURRENT_CONTEXT(ctx);
 326    _mesa_uniform_handle(location, 1, &value, ctx, ctx->_Shader->ActiveProgram);
 327 }
 328
 329 void GLAPIENTRY
 330 _mesa_UniformHandleui64vARB(GLint location, GLsizei count,
 331                             const GLuint64 *value)
 332 {
 333    GET_CURRENT_CONTEXT(ctx);
 334    _mesa_uniform_handle(location, count, value, ctx,
 335                         ctx->_Shader->ActiveProgram);
 336 }
 337
 338
 339 /** Same as above with direct state access **/
 340 void GLAPIENTRY
 341 _mesa_ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 342 {
 343    GET_CURRENT_CONTEXT(ctx);
 344    struct gl_shader_program *shProg =
 345       _mesa_lookup_shader_program_err(ctx, program,
 346             "glProgramUniform1f");
 347    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_FLOAT, 1);
 348 }
 349
 350 void GLAPIENTRY
 351 _mesa_ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 352 {
 353    GET_CURRENT_CONTEXT(ctx);
 354    GLfloat v[2];
 355    struct gl_shader_program *shProg;
 356    v[0] = v0;
 357    v[1] = v1;
 358    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2f");
 359    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_FLOAT, 2);
 360 }
 361
 362 void GLAPIENTRY
 363 _mesa_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1,
 364                        GLfloat v2)
 365 {
 366    GET_CURRENT_CONTEXT(ctx);
 367    GLfloat v[3];
 368    struct gl_shader_program *shProg;
 369    v[0] = v0;
 370    v[1] = v1;
 371    v[2] = v2;
 372    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3f");
 373    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_FLOAT, 3);
 374 }
 375
 376 void GLAPIENTRY
 377 _mesa_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1,
 378                        GLfloat v2, GLfloat v3)
 379 {
 380    GET_CURRENT_CONTEXT(ctx);
 381    GLfloat v[4];
 382    struct gl_shader_program *shProg;
 383    v[0] = v0;
 384    v[1] = v1;
 385    v[2] = v2;
 386    v[3] = v3;
 387    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4f");
 388    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_FLOAT, 4);
 389 }
 390
 391 void GLAPIENTRY
 392 _mesa_ProgramUniform1i(GLuint program, GLint location, GLint v0)
 393 {
 394    GET_CURRENT_CONTEXT(ctx);
 395    struct gl_shader_program *shProg =
 396       _mesa_lookup_shader_program_err(ctx, program,
 397             "glProgramUniform1i");
 398    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_INT, 1);
 399 }
 400
 401 void GLAPIENTRY
 402 _mesa_ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 403 {
 404    GET_CURRENT_CONTEXT(ctx);
 405    GLint v[2];
 406    struct gl_shader_program *shProg;
 407    v[0] = v0;
 408    v[1] = v1;
 409    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2i");
 410    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT, 2);
 411 }
 412
 413 void GLAPIENTRY
 414 _mesa_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1,
 415                        GLint v2)
 416 {
 417    GET_CURRENT_CONTEXT(ctx);
 418    GLint v[3];
 419    struct gl_shader_program *shProg;
 420    v[0] = v0;
 421    v[1] = v1;
 422    v[2] = v2;
 423    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3i");
 424    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT, 3);
 425 }
 426
 427 void GLAPIENTRY
 428 _mesa_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1,
 429                        GLint v2, GLint v3)
 430 {
 431    GET_CURRENT_CONTEXT(ctx);
 432    GLint v[4];
 433    struct gl_shader_program *shProg;
 434    v[0] = v0;
 435    v[1] = v1;
 436    v[2] = v2;
 437    v[3] = v3;
 438    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4i");
 439    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT, 4);
 440 }
 441
 442 void GLAPIENTRY
 443 _mesa_ProgramUniform1fv(GLuint program, GLint location, GLsizei count,
 444                         const GLfloat * value)
 445 {
 446    GET_CURRENT_CONTEXT(ctx);
 447    struct gl_shader_program *shProg =
 448       _mesa_lookup_shader_program_err(ctx, program,
 449             "glProgramUniform1fv");
 450    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 1);
 451 }
 452
 453 void GLAPIENTRY
 454 _mesa_ProgramUniform2fv(GLuint program, GLint location, GLsizei count,
 455                         const GLfloat * value)
 456 {
 457    GET_CURRENT_CONTEXT(ctx);
 458    struct gl_shader_program *shProg =
 459       _mesa_lookup_shader_program_err(ctx, program,
 460             "glProgramUniform2fv");
 461    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 2);
 462 }
 463
 464 void GLAPIENTRY
 465 _mesa_ProgramUniform3fv(GLuint program, GLint location, GLsizei count,
 466                         const GLfloat * value)
 467 {
 468    GET_CURRENT_CONTEXT(ctx);
 469    struct gl_shader_program *shProg =
 470       _mesa_lookup_shader_program_err(ctx, program,
 471             "glProgramUniform3fv");
 472    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 3);
 473 }
 474
 475 void GLAPIENTRY
 476 _mesa_ProgramUniform4fv(GLuint program, GLint location, GLsizei count,
 477                         const GLfloat * value)
 478 {
 479    GET_CURRENT_CONTEXT(ctx);
 480    struct gl_shader_program *shProg =
 481       _mesa_lookup_shader_program_err(ctx, program,
 482             "glProgramUniform4fv");
 483    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 4);
 484 }
 485
 486 void GLAPIENTRY
 487 _mesa_ProgramUniform1iv(GLuint program, GLint location, GLsizei count,
 488                         const GLint * value)
 489 {
 490    GET_CURRENT_CONTEXT(ctx);
 491    struct gl_shader_program *shProg =
 492       _mesa_lookup_shader_program_err(ctx, program,
 493             "glProgramUniform1iv");
 494    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 1);
 495 }
 496
 497 void GLAPIENTRY
 498 _mesa_ProgramUniform2iv(GLuint program, GLint location, GLsizei count,
 499                         const GLint * value)
 500 {
 501    GET_CURRENT_CONTEXT(ctx);
 502    struct gl_shader_program *shProg =
 503       _mesa_lookup_shader_program_err(ctx, program,
 504             "glProgramUniform2iv");
 505    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 2);
 506 }
 507
 508 void GLAPIENTRY
 509 _mesa_ProgramUniform3iv(GLuint program, GLint location, GLsizei count,
 510                         const GLint * value)
 511 {
 512    GET_CURRENT_CONTEXT(ctx);
 513    struct gl_shader_program *shProg =
 514       _mesa_lookup_shader_program_err(ctx, program,
 515             "glProgramUniform3iv");
 516    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 3);
 517 }
 518
 519 void GLAPIENTRY
 520 _mesa_ProgramUniform4iv(GLuint program, GLint location, GLsizei count,
 521                         const GLint * value)
 522 {
 523    GET_CURRENT_CONTEXT(ctx);
 524    struct gl_shader_program *shProg =
 525       _mesa_lookup_shader_program_err(ctx, program,
 526             "glProgramUniform4iv");
 527    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 4);
 528 }
 529
 530 void GLAPIENTRY
 531 _mesa_ProgramUniformHandleui64ARB(GLuint program, GLint location,
 532                                   GLuint64 value)
 533 {
 534    GET_CURRENT_CONTEXT(ctx);
 535    struct gl_shader_program *shProg =
 536       _mesa_lookup_shader_program_err(ctx, program,
 537             "glProgramUniformHandleui64ARB");
 538    _mesa_uniform_handle(location, 1, &value, ctx, shProg);
 539 }
 540
 541 void GLAPIENTRY
 542 _mesa_ProgramUniformHandleui64vARB(GLuint program, GLint location,
 543                                    GLsizei count, const GLuint64 *values)
 544 {
 545    GET_CURRENT_CONTEXT(ctx);
 546    struct gl_shader_program *shProg =
 547       _mesa_lookup_shader_program_err(ctx, program,
 548             "glProgramUniformHandleui64vARB");
 549    _mesa_uniform_handle(location, count, values, ctx, shProg);
 550 }
 551
 552
 553 /** OpenGL 3.0 GLuint-valued functions **/
 554 void GLAPIENTRY
 555 _mesa_Uniform1ui(GLint location, GLuint v0)
 556 {
 557    GET_CURRENT_CONTEXT(ctx);
 558    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 1);
 559 }
 560
 561 void GLAPIENTRY
 562 _mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1)
 563 {
 564    GET_CURRENT_CONTEXT(ctx);
 565    GLuint v[2];
 566    v[0] = v0;
 567    v[1] = v1;
 568    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 2);
 569 }
 570
 571 void GLAPIENTRY
 572 _mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 573 {
 574    GET_CURRENT_CONTEXT(ctx);
 575    GLuint v[3];
 576    v[0] = v0;
 577    v[1] = v1;
 578    v[2] = v2;
 579    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 3);
 580 }
 581
 582 void GLAPIENTRY
 583 _mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 584 {
 585    GET_CURRENT_CONTEXT(ctx);
 586    GLuint v[4];
 587    v[0] = v0;
 588    v[1] = v1;
 589    v[2] = v2;
 590    v[3] = v3;
 591    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 4);
 592 }
 593
 594 void GLAPIENTRY
 595 _mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
 596 {
 597    GET_CURRENT_CONTEXT(ctx);
 598    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 1);
 599 }
 600
 601 void GLAPIENTRY
 602 _mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
 603 {
 604    GET_CURRENT_CONTEXT(ctx);
 605    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 2);
 606 }
 607
 608 void GLAPIENTRY
 609 _mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
 610 {
 611    GET_CURRENT_CONTEXT(ctx);
 612    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 3);
 613 }
 614
 615 void GLAPIENTRY
 616 _mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
 617 {
 618    GET_CURRENT_CONTEXT(ctx);
 619    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 4);
 620 }
 621
 622
 623
 624 void GLAPIENTRY
 625 _mesa_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
 626                           const GLfloat * value)
 627 {
 628    GET_CURRENT_CONTEXT(ctx);
 629    _mesa_uniform_matrix(location, count, transpose, value,
 630                         ctx, ctx->_Shader->ActiveProgram, 2, 2, GLSL_TYPE_FLOAT);
 631 }
 632
 633 void GLAPIENTRY
 634 _mesa_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
 635                           const GLfloat * value)
 636 {
 637    GET_CURRENT_CONTEXT(ctx);
 638    _mesa_uniform_matrix(location, count, transpose, value,
 639                         ctx, ctx->_Shader->ActiveProgram, 3, 3, GLSL_TYPE_FLOAT);
 640 }
 641
 642 void GLAPIENTRY
 643 _mesa_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
 644                           const GLfloat * value)
 645 {
 646    GET_CURRENT_CONTEXT(ctx);
 647    _mesa_uniform_matrix(location, count, transpose, value,
 648                         ctx, ctx->_Shader->ActiveProgram, 4, 4, GLSL_TYPE_FLOAT);
 649 }
 650
 651 /** Same as above with direct state access **/
 652
 653 void GLAPIENTRY
 654 _mesa_ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 655 {
 656    GET_CURRENT_CONTEXT(ctx);
 657    struct gl_shader_program *shProg =
 658       _mesa_lookup_shader_program_err(ctx, program,
 659             "glProgramUniform1ui");
 660    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_UINT, 1);
 661 }
 662
 663 void GLAPIENTRY
 664 _mesa_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 665 {
 666    GET_CURRENT_CONTEXT(ctx);
 667    GLuint v[2];
 668    struct gl_shader_program *shProg;
 669    v[0] = v0;
 670    v[1] = v1;
 671    shProg = _mesa_lookup_shader_program_err(ctx, program,
 672                                             "glProgramUniform2ui");
 673    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT, 2);
 674 }
 675
 676 void GLAPIENTRY
 677 _mesa_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1,
 678                         GLuint v2)
 679 {
 680    GET_CURRENT_CONTEXT(ctx);
 681    GLuint v[3];
 682    struct gl_shader_program *shProg;
 683    v[0] = v0;
 684    v[1] = v1;
 685    v[2] = v2;
 686    shProg = _mesa_lookup_shader_program_err(ctx, program,
 687                                             "glProgramUniform3ui");
 688    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT, 3);
 689 }
 690
 691 void GLAPIENTRY
 692 _mesa_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1,
 693                         GLuint v2, GLuint v3)
 694 {
 695    GET_CURRENT_CONTEXT(ctx);
 696    GLuint v[4];
 697    struct gl_shader_program *shProg;
 698    v[0] = v0;
 699    v[1] = v1;
 700    v[2] = v2;
 701    v[3] = v3;
 702    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4ui");
 703    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT, 4);
 704 }
 705
 706 void GLAPIENTRY
 707 _mesa_ProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
 708                          const GLuint *value)
 709 {
 710    GET_CURRENT_CONTEXT(ctx);
 711    struct gl_shader_program *shProg =
 712       _mesa_lookup_shader_program_err(ctx, program,
 713             "glProgramUniform1uiv");
 714    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 1);
 715 }
 716
 717 void GLAPIENTRY
 718 _mesa_ProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
 719                          const GLuint *value)
 720 {
 721    GET_CURRENT_CONTEXT(ctx);
 722    struct gl_shader_program *shProg =
 723       _mesa_lookup_shader_program_err(ctx, program,
 724             "glProgramUniform2uiv");
 725    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 2);
 726 }
 727
 728 void GLAPIENTRY
 729 _mesa_ProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
 730                          const GLuint *value)
 731 {
 732    GET_CURRENT_CONTEXT(ctx);
 733    struct gl_shader_program *shProg =
 734       _mesa_lookup_shader_program_err(ctx, program,
 735             "glProgramUniform3uiv");
 736    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 3);
 737 }
 738
 739 void GLAPIENTRY
 740 _mesa_ProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
 741                          const GLuint *value)
 742 {
 743    GET_CURRENT_CONTEXT(ctx);
 744    struct gl_shader_program *shProg =
 745       _mesa_lookup_shader_program_err(ctx, program,
 746             "glProgramUniform4uiv");
 747    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 4);
 748 }
 749
 750
 751
 752 void GLAPIENTRY
 753 _mesa_ProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count,
 754                               GLboolean transpose, const GLfloat * value)
 755 {
 756    GET_CURRENT_CONTEXT(ctx);
 757    struct gl_shader_program *shProg =
 758       _mesa_lookup_shader_program_err(ctx, program,
 759             "glProgramUniformMatrix2fv");
 760    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 2, 2, GLSL_TYPE_FLOAT);
 761 }
 762
 763 void GLAPIENTRY
 764 _mesa_ProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count,
 765                               GLboolean transpose, const GLfloat * value)
 766 {
 767    GET_CURRENT_CONTEXT(ctx);
 768    struct gl_shader_program *shProg =
 769       _mesa_lookup_shader_program_err(ctx, program,
 770             "glProgramUniformMatrix3fv");
 771    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 3, 3, GLSL_TYPE_FLOAT);
 772 }
 773
 774 void GLAPIENTRY
 775 _mesa_ProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count,
 776                               GLboolean transpose, const GLfloat * value)
 777 {
 778    GET_CURRENT_CONTEXT(ctx);
 779    struct gl_shader_program *shProg =
 780       _mesa_lookup_shader_program_err(ctx, program,
 781             "glProgramUniformMatrix4fv");
 782    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 4, 4, GLSL_TYPE_FLOAT);
 783 }
 784
 785
 786 /**
 787  * Non-square UniformMatrix are OpenGL 2.1
 788  */
 789 void GLAPIENTRY
 790 _mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
 791                          const GLfloat *value)
 792 {
 793    GET_CURRENT_CONTEXT(ctx);
 794    _mesa_uniform_matrix(location, count, transpose, value,
 795                         ctx, ctx->_Shader->ActiveProgram, 2, 3, GLSL_TYPE_FLOAT);
 796 }
 797
 798 void GLAPIENTRY
 799 _mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
 800                          const GLfloat *value)
 801 {
 802    GET_CURRENT_CONTEXT(ctx);
 803    _mesa_uniform_matrix(location, count, transpose, value,
 804                         ctx, ctx->_Shader->ActiveProgram, 3, 2, GLSL_TYPE_FLOAT);
 805 }
 806
 807 void GLAPIENTRY
 808 _mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
 809                          const GLfloat *value)
 810 {
 811    GET_CURRENT_CONTEXT(ctx);
 812    _mesa_uniform_matrix(location, count, transpose, value,
 813                         ctx, ctx->_Shader->ActiveProgram, 2, 4, GLSL_TYPE_FLOAT);
 814 }
 815
 816 void GLAPIENTRY
 817 _mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
 818                          const GLfloat *value)
 819 {
 820    GET_CURRENT_CONTEXT(ctx);
 821    _mesa_uniform_matrix(location, count, transpose, value,
 822                         ctx, ctx->_Shader->ActiveProgram, 4, 2, GLSL_TYPE_FLOAT);
 823 }
 824
 825 void GLAPIENTRY
 826 _mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
 827                          const GLfloat *value)
 828 {
 829    GET_CURRENT_CONTEXT(ctx);
 830    _mesa_uniform_matrix(location, count, transpose, value,
 831                         ctx, ctx->_Shader->ActiveProgram, 3, 4, GLSL_TYPE_FLOAT);
 832 }
 833
 834 void GLAPIENTRY
 835 _mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
 836                          const GLfloat *value)
 837 {
 838    GET_CURRENT_CONTEXT(ctx);
 839    _mesa_uniform_matrix(location, count, transpose, value,
 840                         ctx, ctx->_Shader->ActiveProgram, 4, 3, GLSL_TYPE_FLOAT);
 841 }
 842
 843 /** Same as above with direct state access **/
 844
 845 void GLAPIENTRY
 846 _mesa_ProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count,
 847                                 GLboolean transpose, const GLfloat * value)
 848 {
 849    GET_CURRENT_CONTEXT(ctx);
 850    struct gl_shader_program *shProg =
 851       _mesa_lookup_shader_program_err(ctx, program,
 852             "glProgramUniformMatrix2x3fv");
 853    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 2, 3, GLSL_TYPE_FLOAT);
 854 }
 855
 856 void GLAPIENTRY
 857 _mesa_ProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count,
 858                                 GLboolean transpose, const GLfloat * value)
 859 {
 860    GET_CURRENT_CONTEXT(ctx);
 861    struct gl_shader_program *shProg =
 862       _mesa_lookup_shader_program_err(ctx, program,
 863             "glProgramUniformMatrix3x2fv");
 864    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 3, 2, GLSL_TYPE_FLOAT);
 865 }
 866
 867 void GLAPIENTRY
 868 _mesa_ProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count,
 869                                 GLboolean transpose, const GLfloat * value)
 870 {
 871    GET_CURRENT_CONTEXT(ctx);
 872    struct gl_shader_program *shProg =
 873       _mesa_lookup_shader_program_err(ctx, program,
 874             "glProgramUniformMatrix2x4fv");
 875    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 2, 4, GLSL_TYPE_FLOAT);
 876 }
 877
 878 void GLAPIENTRY
 879 _mesa_ProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count,
 880                                 GLboolean transpose, const GLfloat * value)
 881 {
 882    GET_CURRENT_CONTEXT(ctx);
 883    struct gl_shader_program *shProg =
 884       _mesa_lookup_shader_program_err(ctx, program,
 885             "glProgramUniformMatrix4x2fv");
 886    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 4, 2, GLSL_TYPE_FLOAT);
 887 }
 888
 889 void GLAPIENTRY
 890 _mesa_ProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count,
 891                                 GLboolean transpose, const GLfloat * value)
 892 {
 893    GET_CURRENT_CONTEXT(ctx);
 894    struct gl_shader_program *shProg =
 895       _mesa_lookup_shader_program_err(ctx, program,
 896             "glProgramUniformMatrix3x4fv");
 897    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 3, 4, GLSL_TYPE_FLOAT);
 898 }
 899
 900 void GLAPIENTRY
 901 _mesa_ProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count,
 902                                 GLboolean transpose, const GLfloat * value)
 903 {
 904    GET_CURRENT_CONTEXT(ctx);
 905    struct gl_shader_program *shProg =
 906       _mesa_lookup_shader_program_err(ctx, program,
 907             "glProgramUniformMatrix4x3fv");
 908    _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 4, 3, GLSL_TYPE_FLOAT);
 909 }
 910
 911
 912 void GLAPIENTRY
 913 _mesa_GetnUniformfvARB(GLuint program, GLint location,
 914                        GLsizei bufSize, GLfloat *params)
 915 {
 916    GET_CURRENT_CONTEXT(ctx);
 917    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_FLOAT, params);
 918 }
 919
 920 void GLAPIENTRY
 921 _mesa_GetUniformfv(GLuint program, GLint location, GLfloat *params)
 922 {
 923    _mesa_GetnUniformfvARB(program, location, INT_MAX, params);
 924 }
 925
 926
 927 void GLAPIENTRY
 928 _mesa_GetnUniformivARB(GLuint program, GLint location,
 929                        GLsizei bufSize, GLint *params)
 930 {
 931    GET_CURRENT_CONTEXT(ctx);
 932    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT, params);
 933 }
 934
 935 void GLAPIENTRY
 936 _mesa_GetUniformiv(GLuint program, GLint location, GLint *params)
 937 {
 938    _mesa_GetnUniformivARB(program, location, INT_MAX, params);
 939 }
 940
 941
 942 /* GL3 */
 943 void GLAPIENTRY
 944 _mesa_GetnUniformuivARB(GLuint program, GLint location,
 945                         GLsizei bufSize, GLuint *params)
 946 {
 947    GET_CURRENT_CONTEXT(ctx);
 948    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT, params);
 949 }
 950
 951 void GLAPIENTRY
 952 _mesa_GetUniformuiv(GLuint program, GLint location, GLuint *params)
 953 {
 954    _mesa_GetnUniformuivARB(program, location, INT_MAX, params);
 955 }
 956
 957
 958 /* GL4 */
 959 void GLAPIENTRY
 960 _mesa_GetnUniformdvARB(GLuint program, GLint location,
 961                        GLsizei bufSize, GLdouble *params)
 962 {
 963    GET_CURRENT_CONTEXT(ctx);
 964
 965    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_DOUBLE, params);
 966 }
 967
 968 void GLAPIENTRY
 969 _mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params)
 970 {
 971    _mesa_GetnUniformdvARB(program, location, INT_MAX, params);
 972 }
 973
 974 void GLAPIENTRY
 975 _mesa_GetnUniformi64vARB(GLuint program, GLint location,
 976                          GLsizei bufSize, GLint64 *params)
 977 {
 978    GET_CURRENT_CONTEXT(ctx);
 979    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT64, params);
 980 }
 981 void GLAPIENTRY
 982 _mesa_GetUniformi64vARB(GLuint program, GLint location, GLint64 *params)
 983 {
 984    _mesa_GetnUniformi64vARB(program, location, INT_MAX, params);
 985 }
 986
 987 void GLAPIENTRY
 988 _mesa_GetnUniformui64vARB(GLuint program, GLint location,
 989                          GLsizei bufSize, GLuint64 *params)
 990 {
 991    GET_CURRENT_CONTEXT(ctx);
 992    _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT64, params);
 993 }
 994
 995 void GLAPIENTRY
 996 _mesa_GetUniformui64vARB(GLuint program, GLint location, GLuint64 *params)
 997 {
 998    _mesa_GetnUniformui64vARB(program, location, INT_MAX, params);
 999 }
1000
1001
1002 GLint GLAPIENTRY
1003 _mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name)
1004 {
1005    struct gl_shader_program *shProg;
1006
1007    GET_CURRENT_CONTEXT(ctx);
1008
1009    shProg = _mesa_lookup_shader_program_err(ctx, programObj,
1010                                             "glGetUniformLocation");
1011    if (!shProg)
1012       return -1;
1013
1014    /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says:
1015     *
1016     *     "If program has not been successfully linked, the error
1017     *     INVALID_OPERATION is generated."
1018     */
1019    if (shProg->data->LinkStatus == linking_failure) {
1020       _mesa_error(ctx, GL_INVALID_OPERATION,
1021                   "glGetUniformLocation(program not linked)");
1022       return -1;
1023    }
1024
1025    return _mesa_program_resource_location(shProg, GL_UNIFORM, name);
1026 }
1027
1028 GLuint GLAPIENTRY
1029 _mesa_GetUniformBlockIndex(GLuint program,
1030                            const GLchar *uniformBlockName)
1031 {
1032    GET_CURRENT_CONTEXT(ctx);
1033    struct gl_shader_program *shProg;
1034
1035    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1036       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex");
1037       return GL_INVALID_INDEX;
1038    }
1039
1040    shProg = _mesa_lookup_shader_program_err(ctx, program,
1041                                             "glGetUniformBlockIndex");
1042    if (!shProg)
1043       return GL_INVALID_INDEX;
1044
1045    struct gl_program_resource *res =
1046       _mesa_program_resource_find_name(shProg, GL_UNIFORM_BLOCK,
1047                                        uniformBlockName, NULL);
1048    if (!res)
1049       return GL_INVALID_INDEX;
1050
1051    return _mesa_program_resource_index(shProg, res);
1052 }
1053
1054 void GLAPIENTRY
1055 _mesa_GetUniformIndices(GLuint program,
1056                         GLsizei uniformCount,
1057                         const GLchar * const *uniformNames,
1058                         GLuint *uniformIndices)
1059 {
1060    GET_CURRENT_CONTEXT(ctx);
1061    GLsizei i;
1062    struct gl_shader_program *shProg;
1063
1064    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1065       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices");
1066       return;
1067    }
1068
1069    shProg = _mesa_lookup_shader_program_err(ctx, program,
1070                                             "glGetUniformIndices");
1071    if (!shProg)
1072       return;
1073
1074    if (uniformCount < 0) {
1075       _mesa_error(ctx, GL_INVALID_VALUE,
1076                   "glGetUniformIndices(uniformCount < 0)");
1077       return;
1078    }
1079
1080    for (i = 0; i < uniformCount; i++) {
1081       struct gl_program_resource *res =
1082          _mesa_program_resource_find_name(shProg, GL_UNIFORM, uniformNames[i],
1083                                           NULL);
1084       uniformIndices[i] = _mesa_program_resource_index(shProg, res);
1085    }
1086 }
1087
1088 void GLAPIENTRY
1089 _mesa_UniformBlockBinding(GLuint program,
1090                           GLuint uniformBlockIndex,
1091                           GLuint uniformBlockBinding)
1092 {
1093    GET_CURRENT_CONTEXT(ctx);
1094    struct gl_shader_program *shProg;
1095
1096    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1097       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding");
1098       return;
1099    }
1100
1101    shProg = _mesa_lookup_shader_program_err(ctx, program,
1102                                             "glUniformBlockBinding");
1103    if (!shProg)
1104       return;
1105
1106    if (uniformBlockIndex >= shProg->data->NumUniformBlocks) {
1107       _mesa_error(ctx, GL_INVALID_VALUE,
1108                   "glUniformBlockBinding(block index %u >= %u)",
1109                   uniformBlockIndex, shProg->data->NumUniformBlocks);
1110       return;
1111    }
1112
1113    if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) {
1114       _mesa_error(ctx, GL_INVALID_VALUE,
1115                   "glUniformBlockBinding(block binding %u >= %u)",
1116                   uniformBlockBinding, ctx->Const.MaxUniformBufferBindings);
1117       return;
1118    }
1119
1120    if (shProg->data->UniformBlocks[uniformBlockIndex].Binding !=
1121        uniformBlockBinding) {
1122
1123       FLUSH_VERTICES(ctx, 0);
1124       ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
1125
1126       shProg->data->UniformBlocks[uniformBlockIndex].Binding =
1127          uniformBlockBinding;
1128    }
1129 }
1130
1131 void GLAPIENTRY
1132 _mesa_ShaderStorageBlockBinding(GLuint program,
1133                                 GLuint shaderStorageBlockIndex,
1134                                 GLuint shaderStorageBlockBinding)
1135 {
1136    GET_CURRENT_CONTEXT(ctx);
1137    struct gl_shader_program *shProg;
1138
1139    if (!ctx->Extensions.ARB_shader_storage_buffer_object) {
1140       _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderStorageBlockBinding");
1141       return;
1142    }
1143
1144    shProg = _mesa_lookup_shader_program_err(ctx, program,
1145                                             "glShaderStorageBlockBinding");
1146    if (!shProg)
1147       return;
1148
1149    if (shaderStorageBlockIndex >= shProg->data->NumShaderStorageBlocks) {
1150       _mesa_error(ctx, GL_INVALID_VALUE,
1151                   "glShaderStorageBlockBinding(block index %u >= %u)",
1152                   shaderStorageBlockIndex,
1153                   shProg->data->NumShaderStorageBlocks);
1154       return;
1155    }
1156
1157    if (shaderStorageBlockBinding >= ctx->Const.MaxShaderStorageBufferBindings) {
1158       _mesa_error(ctx, GL_INVALID_VALUE,
1159                   "glShaderStorageBlockBinding(block binding %u >= %u)",
1160                   shaderStorageBlockBinding,
1161                   ctx->Const.MaxShaderStorageBufferBindings);
1162       return;
1163    }
1164
1165    if (shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding !=
1166        shaderStorageBlockBinding) {
1167
1168       FLUSH_VERTICES(ctx, 0);
1169       ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer;
1170
1171       shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding =
1172          shaderStorageBlockBinding;
1173    }
1174 }
1175
1176 /**
1177  * Generic program resource property query.
1178  */
1179 static void
1180 mesa_bufferiv(struct gl_shader_program *shProg, GLenum type,
1181               GLuint index, GLenum pname, GLint *params, const char *caller)
1182 {
1183    GET_CURRENT_CONTEXT(ctx);
1184    struct gl_program_resource *res =
1185       _mesa_program_resource_find_index(shProg, type, index);
1186
1187    if (!res) {
1188       _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index);
1189       return;
1190    }
1191
1192    switch (pname) {
1193    case GL_UNIFORM_BLOCK_BINDING:
1194    case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1195       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING,
1196                                   params, caller);
1197       return;
1198    case GL_UNIFORM_BLOCK_DATA_SIZE:
1199    case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
1200       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE,
1201                                   params, caller);
1202       return;
1203    case GL_UNIFORM_BLOCK_NAME_LENGTH:
1204       _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH,
1205                                   params, caller);
1206       return;
1207    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
1208    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
1209       _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES,
1210                                   params, caller);
1211       return;
1212    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
1213    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
1214       _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES,
1215                                   params, caller);
1216       return;
1217    case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
1218    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
1219       _mesa_program_resource_prop(shProg, res, index,
1220                                   GL_REFERENCED_BY_VERTEX_SHADER, params,
1221                                   caller);
1222       return;
1223
1224    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER:
1225    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
1226       _mesa_program_resource_prop(shProg, res, index,
1227                                   GL_REFERENCED_BY_TESS_CONTROL_SHADER, params,
1228                                   caller);
1229       return;
1230
1231    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER:
1232    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
1233       _mesa_program_resource_prop(shProg, res, index,
1234                                   GL_REFERENCED_BY_TESS_EVALUATION_SHADER, params,
1235                                   caller);
1236       return;
1237
1238    case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
1239    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
1240       _mesa_program_resource_prop(shProg, res, index,
1241                                   GL_REFERENCED_BY_GEOMETRY_SHADER, params,
1242                                   caller);
1243       return;
1244    case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
1245    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
1246       _mesa_program_resource_prop(shProg, res, index,
1247                                   GL_REFERENCED_BY_FRAGMENT_SHADER, params,
1248                                   caller);
1249       return;
1250    case GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER:
1251    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER:
1252       _mesa_program_resource_prop(shProg, res, index,
1253                                   GL_REFERENCED_BY_COMPUTE_SHADER, params,
1254                                   caller);
1255       return;
1256    default:
1257       _mesa_error(ctx, GL_INVALID_ENUM,
1258                   "%s(pname 0x%x (%s))", caller, pname,
1259                   _mesa_enum_to_string(pname));
1260       return;
1261    }
1262 }
1263
1264
1265 void GLAPIENTRY
1266 _mesa_GetActiveUniformBlockiv(GLuint program,
1267                               GLuint uniformBlockIndex,
1268                               GLenum pname,
1269                               GLint *params)
1270 {
1271    GET_CURRENT_CONTEXT(ctx);
1272    struct gl_shader_program *shProg;
1273
1274    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1275       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1276       return;
1277    }
1278
1279    shProg = _mesa_lookup_shader_program_err(ctx, program,
1280                                             "glGetActiveUniformBlockiv");
1281    if (!shProg)
1282       return;
1283
1284    mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params,
1285                  "glGetActiveUniformBlockiv");
1286 }
1287
1288 void GLAPIENTRY
1289 _mesa_GetActiveUniformBlockName(GLuint program,
1290                                 GLuint uniformBlockIndex,
1291                                 GLsizei bufSize,
1292                                 GLsizei *length,
1293                                 GLchar *uniformBlockName)
1294 {
1295    GET_CURRENT_CONTEXT(ctx);
1296    struct gl_shader_program *shProg;
1297
1298    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1299       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1300       return;
1301    }
1302
1303    if (bufSize < 0) {
1304       _mesa_error(ctx, GL_INVALID_VALUE,
1305                   "glGetActiveUniformBlockName(bufSize %d < 0)",
1306                   bufSize);
1307       return;
1308    }
1309
1310    shProg = _mesa_lookup_shader_program_err(ctx, program,
1311                                             "glGetActiveUniformBlockiv");
1312    if (!shProg)
1313       return;
1314
1315    if (uniformBlockName)
1316       _mesa_get_program_resource_name(shProg, GL_UNIFORM_BLOCK,
1317                                       uniformBlockIndex, bufSize, length,
1318                                       uniformBlockName,
1319                                       "glGetActiveUniformBlockName");
1320 }
1321
1322 void GLAPIENTRY
1323 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex,
1324                            GLsizei bufSize, GLsizei *length,
1325                            GLchar *uniformName)
1326 {
1327    GET_CURRENT_CONTEXT(ctx);
1328    struct gl_shader_program *shProg;
1329
1330    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1331       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName");
1332       return;
1333    }
1334
1335    if (bufSize < 0) {
1336       _mesa_error(ctx, GL_INVALID_VALUE,
1337                   "glGetActiveUniformName(bufSize %d < 0)",
1338                   bufSize);
1339       return;
1340    }
1341
1342    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName");
1343
1344    if (!shProg)
1345       return;
1346
1347    _mesa_get_program_resource_name(shProg, GL_UNIFORM, uniformIndex, bufSize,
1348                                    length, uniformName, "glGetActiveUniformName");
1349 }
1350
1351 void GLAPIENTRY
1352 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex,
1353                                      GLenum pname, GLint *params)
1354 {
1355    GET_CURRENT_CONTEXT(ctx);
1356    struct gl_shader_program *shProg;
1357
1358    if (!ctx->Extensions.ARB_shader_atomic_counters) {
1359       _mesa_error(ctx, GL_INVALID_OPERATION,
1360                   "glGetActiveAtomicCounterBufferiv");
1361       return;
1362    }
1363
1364    shProg = _mesa_lookup_shader_program_err(ctx, program,
1365                                             "glGetActiveAtomicCounterBufferiv");
1366    if (!shProg)
1367       return;
1368
1369    mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params,
1370                  "glGetActiveAtomicCounterBufferiv");
1371 }
1372
1373 void GLAPIENTRY
1374 _mesa_Uniform1d(GLint location, GLdouble v0)
1375 {
1376    GET_CURRENT_CONTEXT(ctx);
1377    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 1);
1378 }
1379
1380 void GLAPIENTRY
1381 _mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1)
1382 {
1383    GET_CURRENT_CONTEXT(ctx);
1384    GLdouble v[2];
1385    v[0] = v0;
1386    v[1] = v1;
1387    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 2);
1388 }
1389
1390 void GLAPIENTRY
1391 _mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
1392 {
1393    GET_CURRENT_CONTEXT(ctx);
1394    GLdouble v[3];
1395    v[0] = v0;
1396    v[1] = v1;
1397    v[2] = v2;
1398    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 3);
1399 }
1400
1401 void GLAPIENTRY
1402 _mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2,
1403                 GLdouble v3)
1404 {
1405    GET_CURRENT_CONTEXT(ctx);
1406    GLdouble v[4];
1407    v[0] = v0;
1408    v[1] = v1;
1409    v[2] = v2;
1410    v[3] = v3;
1411    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 4);
1412 }
1413
1414 void GLAPIENTRY
1415 _mesa_Uniform1dv(GLint location, GLsizei count, const GLdouble * value)
1416 {
1417    GET_CURRENT_CONTEXT(ctx);
1418    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 1);
1419 }
1420
1421 void GLAPIENTRY
1422 _mesa_Uniform2dv(GLint location, GLsizei count, const GLdouble * value)
1423 {
1424    GET_CURRENT_CONTEXT(ctx);
1425    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 2);
1426 }
1427
1428 void GLAPIENTRY
1429 _mesa_Uniform3dv(GLint location, GLsizei count, const GLdouble * value)
1430 {
1431    GET_CURRENT_CONTEXT(ctx);
1432    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 3);
1433 }
1434
1435 void GLAPIENTRY
1436 _mesa_Uniform4dv(GLint location, GLsizei count, const GLdouble * value)
1437 {
1438    GET_CURRENT_CONTEXT(ctx);
1439    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 4);
1440 }
1441
1442 void GLAPIENTRY
1443 _mesa_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,
1444                        const GLdouble * value)
1445 {
1446    GET_CURRENT_CONTEXT(ctx);
1447    _mesa_uniform_matrix(location, count, transpose, value,
1448                         ctx, ctx->_Shader->ActiveProgram, 2, 2, GLSL_TYPE_DOUBLE);
1449 }
1450
1451 void GLAPIENTRY
1452 _mesa_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,
1453                        const GLdouble * value)
1454 {
1455    GET_CURRENT_CONTEXT(ctx);
1456    _mesa_uniform_matrix(location, count, transpose, value,
1457                         ctx, ctx->_Shader->ActiveProgram, 3, 3, GLSL_TYPE_DOUBLE);
1458 }
1459
1460 void GLAPIENTRY
1461 _mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
1462                        const GLdouble * value)
1463 {
1464    GET_CURRENT_CONTEXT(ctx);
1465    _mesa_uniform_matrix(location, count, transpose, value,
1466                         ctx, ctx->_Shader->ActiveProgram, 4, 4, GLSL_TYPE_DOUBLE);
1467 }
1468
1469 void GLAPIENTRY
1470 _mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
1471                          const GLdouble *value)
1472 {
1473    GET_CURRENT_CONTEXT(ctx);
1474    _mesa_uniform_matrix(location, count, transpose, value,
1475                         ctx, ctx->_Shader->ActiveProgram, 2, 3, GLSL_TYPE_DOUBLE);
1476 }
1477
1478 void GLAPIENTRY
1479 _mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
1480                          const GLdouble *value)
1481 {
1482    GET_CURRENT_CONTEXT(ctx);
1483    _mesa_uniform_matrix(location, count, transpose, value,
1484                         ctx, ctx->_Shader->ActiveProgram, 3, 2, GLSL_TYPE_DOUBLE);
1485 }
1486
1487 void GLAPIENTRY
1488 _mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
1489                          const GLdouble *value)
1490 {
1491    GET_CURRENT_CONTEXT(ctx);
1492    _mesa_uniform_matrix(location, count, transpose, value,
1493                         ctx, ctx->_Shader->ActiveProgram, 2, 4, GLSL_TYPE_DOUBLE);
1494 }
1495
1496 void GLAPIENTRY
1497 _mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
1498                          const GLdouble *value)
1499 {
1500    GET_CURRENT_CONTEXT(ctx);
1501    _mesa_uniform_matrix(location, count, transpose, value,
1502                         ctx, ctx->_Shader->ActiveProgram, 4, 2, GLSL_TYPE_DOUBLE);
1503 }
1504
1505 void GLAPIENTRY
1506 _mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
1507                          const GLdouble *value)
1508 {
1509    GET_CURRENT_CONTEXT(ctx);
1510    _mesa_uniform_matrix(location, count, transpose, value,
1511                         ctx, ctx->_Shader->ActiveProgram, 3, 4, GLSL_TYPE_DOUBLE);
1512 }
1513
1514 void GLAPIENTRY
1515 _mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
1516                          const GLdouble *value)
1517 {
1518    GET_CURRENT_CONTEXT(ctx);
1519    _mesa_uniform_matrix(location, count, transpose, value,
1520                         ctx, ctx->_Shader->ActiveProgram, 4, 3, GLSL_TYPE_DOUBLE);
1521 }
1522
1523 void GLAPIENTRY
1524 _mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0)
1525 {
1526    GET_CURRENT_CONTEXT(ctx);
1527    struct gl_shader_program *shProg =
1528       _mesa_lookup_shader_program_err(ctx, program,
1529             "glProgramUniform1d");
1530    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_DOUBLE, 1);
1531 }
1532
1533 void GLAPIENTRY
1534 _mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
1535 {
1536    GET_CURRENT_CONTEXT(ctx);
1537    GLdouble v[2];
1538    struct gl_shader_program *shProg;
1539    v[0] = v0;
1540    v[1] = v1;
1541    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d");
1542    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 2);
1543 }
1544
1545 void GLAPIENTRY
1546 _mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1547                        GLdouble v2)
1548 {
1549    GET_CURRENT_CONTEXT(ctx);
1550    GLdouble v[3];
1551    struct gl_shader_program *shProg;
1552    v[0] = v0;
1553    v[1] = v1;
1554    v[2] = v2;
1555    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d");
1556    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 3);
1557 }
1558
1559 void GLAPIENTRY
1560 _mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1561                        GLdouble v2, GLdouble v3)
1562 {
1563    GET_CURRENT_CONTEXT(ctx);
1564    GLdouble v[4];
1565    struct gl_shader_program *shProg;
1566    v[0] = v0;
1567    v[1] = v1;
1568    v[2] = v2;
1569    v[3] = v3;
1570    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d");
1571    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 4);
1572 }
1573
1574 void GLAPIENTRY
1575 _mesa_ProgramUniform1dv(GLuint program, GLint location, GLsizei count,
1576                         const GLdouble * value)
1577 {
1578    GET_CURRENT_CONTEXT(ctx);
1579    struct gl_shader_program *shProg =
1580       _mesa_lookup_shader_program_err(ctx, program,
1581             "glProgramUniform1dv");
1582    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 1);
1583 }
1584
1585 void GLAPIENTRY
1586 _mesa_ProgramUniform2dv(GLuint program, GLint location, GLsizei count,
1587                         const GLdouble * value)
1588 {
1589    GET_CURRENT_CONTEXT(ctx);
1590    struct gl_shader_program *shProg =
1591       _mesa_lookup_shader_program_err(ctx, program,
1592             "glProgramUniform2dv");
1593    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 2);
1594 }
1595
1596 void GLAPIENTRY
1597 _mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count,
1598                         const GLdouble * value)
1599 {
1600    GET_CURRENT_CONTEXT(ctx);
1601    struct gl_shader_program *shProg =
1602       _mesa_lookup_shader_program_err(ctx, program,
1603             "glProgramUniform3dv");
1604    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 3);
1605 }
1606
1607 void GLAPIENTRY
1608 _mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count,
1609                         const GLdouble * value)
1610 {
1611    GET_CURRENT_CONTEXT(ctx);
1612    struct gl_shader_program *shProg =
1613       _mesa_lookup_shader_program_err(ctx, program,
1614             "glProgramUniform4dv");
1615    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 4);
1616 }
1617
1618 void GLAPIENTRY
1619 _mesa_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count,
1620                               GLboolean transpose, const GLdouble * value)
1621 {
1622    GET_CURRENT_CONTEXT(ctx);
1623    struct gl_shader_program *shProg =
1624       _mesa_lookup_shader_program_err(ctx, program,
1625             "glProgramUniformMatrix2dv");
1626    _mesa_uniform_matrix(location, count, transpose, value,
1627                         ctx, shProg, 2, 2, GLSL_TYPE_DOUBLE);
1628 }
1629
1630 void GLAPIENTRY
1631 _mesa_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count,
1632                               GLboolean transpose, const GLdouble * value)
1633 {
1634    GET_CURRENT_CONTEXT(ctx);
1635    struct gl_shader_program *shProg =
1636       _mesa_lookup_shader_program_err(ctx, program,
1637             "glProgramUniformMatrix3dv");
1638    _mesa_uniform_matrix(location, count, transpose, value,
1639                         ctx, shProg, 3, 3, GLSL_TYPE_DOUBLE);
1640 }
1641
1642 void GLAPIENTRY
1643 _mesa_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count,
1644                               GLboolean transpose, const GLdouble * value)
1645 {
1646    GET_CURRENT_CONTEXT(ctx);
1647    struct gl_shader_program *shProg =
1648       _mesa_lookup_shader_program_err(ctx, program,
1649             "glProgramUniformMatrix4dv");
1650    _mesa_uniform_matrix(location, count, transpose, value,
1651                         ctx, shProg, 4, 4, GLSL_TYPE_DOUBLE);
1652 }
1653
1654 void GLAPIENTRY
1655 _mesa_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count,
1656                                 GLboolean transpose, const GLdouble * value)
1657 {
1658    GET_CURRENT_CONTEXT(ctx);
1659    struct gl_shader_program *shProg =
1660       _mesa_lookup_shader_program_err(ctx, program,
1661             "glProgramUniformMatrix2x3dv");
1662    _mesa_uniform_matrix(location, count, transpose, value,
1663                         ctx, shProg, 2, 3, GLSL_TYPE_DOUBLE);
1664 }
1665
1666 void GLAPIENTRY
1667 _mesa_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count,
1668                                 GLboolean transpose, const GLdouble * value)
1669 {
1670    GET_CURRENT_CONTEXT(ctx);
1671    struct gl_shader_program *shProg =
1672       _mesa_lookup_shader_program_err(ctx, program,
1673             "glProgramUniformMatrix3x2dv");
1674    _mesa_uniform_matrix(location, count, transpose, value,
1675                         ctx, shProg, 3, 2, GLSL_TYPE_DOUBLE);
1676 }
1677
1678 void GLAPIENTRY
1679 _mesa_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count,
1680                                 GLboolean transpose, const GLdouble * value)
1681 {
1682    GET_CURRENT_CONTEXT(ctx);
1683    struct gl_shader_program *shProg =
1684       _mesa_lookup_shader_program_err(ctx, program,
1685             "glProgramUniformMatrix2x4dv");
1686    _mesa_uniform_matrix(location, count, transpose, value,
1687                         ctx, shProg, 2, 4, GLSL_TYPE_DOUBLE);
1688 }
1689
1690 void GLAPIENTRY
1691 _mesa_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count,
1692                                 GLboolean transpose, const GLdouble * value)
1693 {
1694    GET_CURRENT_CONTEXT(ctx);
1695    struct gl_shader_program *shProg =
1696       _mesa_lookup_shader_program_err(ctx, program,
1697             "glProgramUniformMatrix4x2dv");
1698    _mesa_uniform_matrix(location, count, transpose, value,
1699                         ctx, shProg, 4, 2, GLSL_TYPE_DOUBLE);
1700 }
1701
1702 void GLAPIENTRY
1703 _mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count,
1704                                 GLboolean transpose, const GLdouble * value)
1705 {
1706    GET_CURRENT_CONTEXT(ctx);
1707    struct gl_shader_program *shProg =
1708       _mesa_lookup_shader_program_err(ctx, program,
1709             "glProgramUniformMatrix3x4dv");
1710    _mesa_uniform_matrix(location, count, transpose, value,
1711                         ctx, shProg, 3, 4, GLSL_TYPE_DOUBLE);
1712 }
1713
1714 void GLAPIENTRY
1715 _mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count,
1716                                 GLboolean transpose, const GLdouble * value)
1717 {
1718    GET_CURRENT_CONTEXT(ctx);
1719    struct gl_shader_program *shProg =
1720       _mesa_lookup_shader_program_err(ctx, program,
1721             "glProgramUniformMatrix4x3dv");
1722    _mesa_uniform_matrix(location, count, transpose, value,
1723                         ctx, shProg, 4, 3, GLSL_TYPE_DOUBLE);
1724 }
1725
1726 void GLAPIENTRY
1727 _mesa_Uniform1i64ARB(GLint location, GLint64 v0)
1728 {
1729    GET_CURRENT_CONTEXT(ctx);
1730    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 1);
1731 }
1732
1733 void GLAPIENTRY
1734 _mesa_Uniform2i64ARB(GLint location, GLint64 v0, GLint64 v1)
1735 {
1736    GET_CURRENT_CONTEXT(ctx);
1737    int64_t v[2];
1738    v[0] = v0;
1739    v[1] = v1;
1740    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 2);
1741 }
1742
1743 void GLAPIENTRY
1744 _mesa_Uniform3i64ARB(GLint location, GLint64 v0, GLint64 v1, GLint64 v2)
1745 {
1746    GET_CURRENT_CONTEXT(ctx);
1747    int64_t v[3];
1748    v[0] = v0;
1749    v[1] = v1;
1750    v[2] = v2;
1751    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 3);
1752 }
1753
1754 void GLAPIENTRY
1755 _mesa_Uniform4i64ARB(GLint location,  GLint64 v0, GLint64 v1, GLint64 v2, GLint64 v3)
1756 {
1757    GET_CURRENT_CONTEXT(ctx);
1758    int64_t v[4];
1759    v[0] = v0;
1760    v[1] = v1;
1761    v[2] = v2;
1762    v[3] = v3;
1763    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 4);
1764 }
1765
1766 void GLAPIENTRY
1767 _mesa_Uniform1i64vARB(GLint location, GLsizei count, const GLint64 *value)
1768 {
1769    GET_CURRENT_CONTEXT(ctx);
1770    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 1);
1771 }
1772
1773 void GLAPIENTRY
1774 _mesa_Uniform2i64vARB(GLint location,  GLsizei count, const GLint64 *value)
1775 {
1776    GET_CURRENT_CONTEXT(ctx);
1777    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 2);
1778 }
1779
1780 void GLAPIENTRY
1781 _mesa_Uniform3i64vARB(GLint location,  GLsizei count, const GLint64 *value)
1782 {
1783    GET_CURRENT_CONTEXT(ctx);
1784    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 3);
1785 }
1786
1787 void GLAPIENTRY
1788 _mesa_Uniform4i64vARB(GLint location,  GLsizei count, const GLint64 *value)
1789 {
1790    GET_CURRENT_CONTEXT(ctx);
1791    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 4);
1792 }
1793
1794 void GLAPIENTRY
1795 _mesa_Uniform1ui64ARB(GLint location,  GLuint64 v0)
1796 {
1797    GET_CURRENT_CONTEXT(ctx);
1798    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 1);
1799 }
1800
1801 void GLAPIENTRY
1802 _mesa_Uniform2ui64ARB(GLint location,  GLuint64 v0, GLuint64 v1)
1803 {
1804    GET_CURRENT_CONTEXT(ctx);
1805    uint64_t v[2];
1806    v[0] = v0;
1807    v[1] = v1;
1808    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 2);
1809 }
1810
1811 void GLAPIENTRY
1812 _mesa_Uniform3ui64ARB(GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2)
1813 {
1814    GET_CURRENT_CONTEXT(ctx);
1815    uint64_t v[3];
1816    v[0] = v0;
1817    v[1] = v1;
1818    v[2] = v2;
1819    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 3);
1820 }
1821
1822 void GLAPIENTRY
1823 _mesa_Uniform4ui64ARB(GLint location,  GLuint64 v0, GLuint64 v1, GLuint64 v2, GLuint64 v3)
1824 {
1825    GET_CURRENT_CONTEXT(ctx);
1826    uint64_t v[4];
1827    v[0] = v0;
1828    v[1] = v1;
1829    v[2] = v2;
1830    v[3] = v3;
1831    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 4);
1832 }
1833
1834 void GLAPIENTRY
1835 _mesa_Uniform1ui64vARB(GLint location,  GLsizei count, const GLuint64 *value)
1836 {
1837    GET_CURRENT_CONTEXT(ctx);
1838    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 1);
1839 }
1840
1841 void GLAPIENTRY
1842 _mesa_Uniform2ui64vARB(GLint location,  GLsizei count, const GLuint64 *value)
1843 {
1844    GET_CURRENT_CONTEXT(ctx);
1845    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 2);
1846 }
1847
1848 void GLAPIENTRY
1849 _mesa_Uniform3ui64vARB(GLint location,  GLsizei count, const GLuint64 *value)
1850 {
1851    GET_CURRENT_CONTEXT(ctx);
1852    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 3);
1853 }
1854
1855 void GLAPIENTRY
1856 _mesa_Uniform4ui64vARB(GLint location,  GLsizei count, const GLuint64 *value)
1857 {
1858    GET_CURRENT_CONTEXT(ctx);
1859    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 4);
1860 }
1861
1862 /* DSA entrypoints */
1863 void GLAPIENTRY
1864 _mesa_ProgramUniform1i64ARB(GLuint program, GLint location, GLint64 v0)
1865 {
1866    GET_CURRENT_CONTEXT(ctx);
1867    struct gl_shader_program *shProg =
1868       _mesa_lookup_shader_program_err(ctx, program,
1869             "glProgramUniform1i64ARB");
1870    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_INT64, 1);
1871 }
1872
1873 void GLAPIENTRY
1874 _mesa_ProgramUniform2i64ARB(GLuint program, GLint location, GLint64 v0, GLint64 v1)
1875 {
1876    GET_CURRENT_CONTEXT(ctx);
1877    struct gl_shader_program *shProg =
1878       _mesa_lookup_shader_program_err(ctx, program,
1879                                       "glProgramUniform2i64ARB");
1880    int64_t v[2];
1881    v[0] = v0;
1882    v[1] = v1;
1883    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 2);
1884 }
1885
1886 void GLAPIENTRY
1887 _mesa_ProgramUniform3i64ARB(GLuint program, GLint location, GLint64 v0, GLint64 v1, GLint64 v2)
1888 {
1889    GET_CURRENT_CONTEXT(ctx);
1890    struct gl_shader_program *shProg =
1891       _mesa_lookup_shader_program_err(ctx, program,
1892                                       "glProgramUniform3i64ARB");
1893    int64_t v[3];
1894    v[0] = v0;
1895    v[1] = v1;
1896    v[2] = v2;
1897    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 3);
1898 }
1899
1900 void GLAPIENTRY
1901 _mesa_ProgramUniform4i64ARB(GLuint program, GLint location,  GLint64 v0, GLint64 v1, GLint64 v2, GLint64 v3)
1902 {
1903    GET_CURRENT_CONTEXT(ctx);
1904    struct gl_shader_program *shProg =
1905       _mesa_lookup_shader_program_err(ctx, program,
1906                                       "glProgramUniform4i64ARB");
1907    int64_t v[4];
1908    v[0] = v0;
1909    v[1] = v1;
1910    v[2] = v2;
1911    v[3] = v3;
1912    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 4);
1913 }
1914
1915 void GLAPIENTRY
1916 _mesa_ProgramUniform1i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value)
1917 {
1918    GET_CURRENT_CONTEXT(ctx);
1919    struct gl_shader_program *shProg =
1920       _mesa_lookup_shader_program_err(ctx, program,
1921                                       "glProgramUniform1i64vARB");
1922    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 1);
1923 }
1924
1925 void GLAPIENTRY
1926 _mesa_ProgramUniform2i64vARB(GLuint program, GLint location,  GLsizei count, const GLint64 *value)
1927 {
1928    GET_CURRENT_CONTEXT(ctx);
1929    struct gl_shader_program *shProg =
1930       _mesa_lookup_shader_program_err(ctx, program,
1931                                       "glProgramUniform2i64vARB");
1932    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 2);
1933 }
1934
1935 void GLAPIENTRY
1936 _mesa_ProgramUniform3i64vARB(GLuint program, GLint location,  GLsizei count, const GLint64 *value)
1937 {
1938    GET_CURRENT_CONTEXT(ctx);
1939    struct gl_shader_program *shProg =
1940       _mesa_lookup_shader_program_err(ctx, program,
1941                                       "glProgramUniform3i64vARB");
1942    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 3);
1943 }
1944
1945 void GLAPIENTRY
1946 _mesa_ProgramUniform4i64vARB(GLuint program, GLint location,  GLsizei count, const GLint64 *value)
1947 {
1948    GET_CURRENT_CONTEXT(ctx);
1949    struct gl_shader_program *shProg =
1950       _mesa_lookup_shader_program_err(ctx, program,
1951                                       "glProgramUniform4i64vARB");
1952    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 4);
1953 }
1954
1955 void GLAPIENTRY
1956 _mesa_ProgramUniform1ui64ARB(GLuint program, GLint location,  GLuint64 v0)
1957 {
1958    GET_CURRENT_CONTEXT(ctx);
1959    struct gl_shader_program *shProg =
1960       _mesa_lookup_shader_program_err(ctx, program,
1961                                       "glProgramUniform1ui64ARB");
1962    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_UINT64, 1);
1963 }
1964
1965 void GLAPIENTRY
1966 _mesa_ProgramUniform2ui64ARB(GLuint program, GLint location,  GLuint64 v0, GLuint64 v1)
1967 {
1968    GET_CURRENT_CONTEXT(ctx);
1969    struct gl_shader_program *shProg =
1970       _mesa_lookup_shader_program_err(ctx, program,
1971                                       "glProgramUniform2ui64ARB");
1972    uint64_t v[2];
1973    v[0] = v0;
1974    v[1] = v1;
1975    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 2);
1976 }
1977
1978 void GLAPIENTRY
1979 _mesa_ProgramUniform3ui64ARB(GLuint program, GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2)
1980 {
1981    GET_CURRENT_CONTEXT(ctx);
1982    struct gl_shader_program *shProg =
1983       _mesa_lookup_shader_program_err(ctx, program,
1984                                       "glProgramUniform3ui64ARB");
1985    uint64_t v[3];
1986    v[0] = v0;
1987    v[1] = v1;
1988    v[2] = v2;
1989    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 3);
1990 }
1991
1992 void GLAPIENTRY
1993 _mesa_ProgramUniform4ui64ARB(GLuint program, GLint location,  GLuint64 v0, GLuint64 v1, GLuint64 v2, GLuint64 v3)
1994 {
1995    GET_CURRENT_CONTEXT(ctx);
1996    struct gl_shader_program *shProg =
1997       _mesa_lookup_shader_program_err(ctx, program,
1998                                       "glProgramUniform4ui64ARB");
1999    uint64_t v[4];
2000    v[0] = v0;
2001    v[1] = v1;
2002    v[2] = v2;
2003    v[3] = v3;
2004    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 4);
2005 }
2006
2007 void GLAPIENTRY
2008 _mesa_ProgramUniform1ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2009 {
2010    GET_CURRENT_CONTEXT(ctx);
2011    struct gl_shader_program *shProg =
2012       _mesa_lookup_shader_program_err(ctx, program,
2013                                       "glProgramUniform1ui64vARB");
2014    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 1);
2015 }
2016
2017 void GLAPIENTRY
2018 _mesa_ProgramUniform2ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2019 {
2020    GET_CURRENT_CONTEXT(ctx);
2021    struct gl_shader_program *shProg =
2022       _mesa_lookup_shader_program_err(ctx, program,
2023                                       "glProgramUniform2ui64vARB");
2024    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 2);
2025 }
2026
2027 void GLAPIENTRY
2028 _mesa_ProgramUniform3ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2029 {
2030    GET_CURRENT_CONTEXT(ctx);
2031    struct gl_shader_program *shProg =
2032       _mesa_lookup_shader_program_err(ctx, program,
2033                                       "glProgramUniform3ui64vARB");
2034    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 3);
2035 }
2036
2037 void GLAPIENTRY
2038 _mesa_ProgramUniform4ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2039 {
2040    GET_CURRENT_CONTEXT(ctx);
2041    struct gl_shader_program *shProg =
2042       _mesa_lookup_shader_program_err(ctx, program,
2043                                       "glProgramUniform4ui64vARB");
2044    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 4);
2045 }