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 static void
1089 uniform_block_binding(struct gl_context *ctx, struct gl_shader_program *shProg,
1090                       GLuint uniformBlockIndex, GLuint uniformBlockBinding)
1091 {
1092    if (shProg->data->UniformBlocks[uniformBlockIndex].Binding !=
1093        uniformBlockBinding) {
1094
1095       FLUSH_VERTICES(ctx, 0);
1096       ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
1097
1098       shProg->data->UniformBlocks[uniformBlockIndex].Binding =
1099          uniformBlockBinding;
1100    }
1101 }
1102
1103 void GLAPIENTRY
1104 _mesa_UniformBlockBinding(GLuint program,
1105                           GLuint uniformBlockIndex,
1106                           GLuint uniformBlockBinding)
1107 {
1108    GET_CURRENT_CONTEXT(ctx);
1109    struct gl_shader_program *shProg;
1110
1111    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1112       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding");
1113       return;
1114    }
1115
1116    shProg = _mesa_lookup_shader_program_err(ctx, program,
1117                                             "glUniformBlockBinding");
1118    if (!shProg)
1119       return;
1120
1121    if (uniformBlockIndex >= shProg->data->NumUniformBlocks) {
1122       _mesa_error(ctx, GL_INVALID_VALUE,
1123                   "glUniformBlockBinding(block index %u >= %u)",
1124                   uniformBlockIndex, shProg->data->NumUniformBlocks);
1125       return;
1126    }
1127
1128    if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) {
1129       _mesa_error(ctx, GL_INVALID_VALUE,
1130                   "glUniformBlockBinding(block binding %u >= %u)",
1131                   uniformBlockBinding, ctx->Const.MaxUniformBufferBindings);
1132       return;
1133    }
1134
1135    uniform_block_binding(ctx, shProg, uniformBlockIndex, uniformBlockBinding);
1136 }
1137
1138 void GLAPIENTRY
1139 _mesa_ShaderStorageBlockBinding(GLuint program,
1140                                 GLuint shaderStorageBlockIndex,
1141                                 GLuint shaderStorageBlockBinding)
1142 {
1143    GET_CURRENT_CONTEXT(ctx);
1144    struct gl_shader_program *shProg;
1145
1146    if (!ctx->Extensions.ARB_shader_storage_buffer_object) {
1147       _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderStorageBlockBinding");
1148       return;
1149    }
1150
1151    shProg = _mesa_lookup_shader_program_err(ctx, program,
1152                                             "glShaderStorageBlockBinding");
1153    if (!shProg)
1154       return;
1155
1156    if (shaderStorageBlockIndex >= shProg->data->NumShaderStorageBlocks) {
1157       _mesa_error(ctx, GL_INVALID_VALUE,
1158                   "glShaderStorageBlockBinding(block index %u >= %u)",
1159                   shaderStorageBlockIndex,
1160                   shProg->data->NumShaderStorageBlocks);
1161       return;
1162    }
1163
1164    if (shaderStorageBlockBinding >= ctx->Const.MaxShaderStorageBufferBindings) {
1165       _mesa_error(ctx, GL_INVALID_VALUE,
1166                   "glShaderStorageBlockBinding(block binding %u >= %u)",
1167                   shaderStorageBlockBinding,
1168                   ctx->Const.MaxShaderStorageBufferBindings);
1169       return;
1170    }
1171
1172    if (shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding !=
1173        shaderStorageBlockBinding) {
1174
1175       FLUSH_VERTICES(ctx, 0);
1176       ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer;
1177
1178       shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding =
1179          shaderStorageBlockBinding;
1180    }
1181 }
1182
1183 /**
1184  * Generic program resource property query.
1185  */
1186 static void
1187 mesa_bufferiv(struct gl_shader_program *shProg, GLenum type,
1188               GLuint index, GLenum pname, GLint *params, const char *caller)
1189 {
1190    GET_CURRENT_CONTEXT(ctx);
1191    struct gl_program_resource *res =
1192       _mesa_program_resource_find_index(shProg, type, index);
1193
1194    if (!res) {
1195       _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index);
1196       return;
1197    }
1198
1199    switch (pname) {
1200    case GL_UNIFORM_BLOCK_BINDING:
1201    case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1202       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING,
1203                                   params, caller);
1204       return;
1205    case GL_UNIFORM_BLOCK_DATA_SIZE:
1206    case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
1207       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE,
1208                                   params, caller);
1209       return;
1210    case GL_UNIFORM_BLOCK_NAME_LENGTH:
1211       _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH,
1212                                   params, caller);
1213       return;
1214    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
1215    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
1216       _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES,
1217                                   params, caller);
1218       return;
1219    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
1220    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
1221       _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES,
1222                                   params, caller);
1223       return;
1224    case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
1225    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
1226       _mesa_program_resource_prop(shProg, res, index,
1227                                   GL_REFERENCED_BY_VERTEX_SHADER, params,
1228                                   caller);
1229       return;
1230
1231    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER:
1232    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
1233       _mesa_program_resource_prop(shProg, res, index,
1234                                   GL_REFERENCED_BY_TESS_CONTROL_SHADER, params,
1235                                   caller);
1236       return;
1237
1238    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER:
1239    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
1240       _mesa_program_resource_prop(shProg, res, index,
1241                                   GL_REFERENCED_BY_TESS_EVALUATION_SHADER, params,
1242                                   caller);
1243       return;
1244
1245    case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
1246    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
1247       _mesa_program_resource_prop(shProg, res, index,
1248                                   GL_REFERENCED_BY_GEOMETRY_SHADER, params,
1249                                   caller);
1250       return;
1251    case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
1252    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
1253       _mesa_program_resource_prop(shProg, res, index,
1254                                   GL_REFERENCED_BY_FRAGMENT_SHADER, params,
1255                                   caller);
1256       return;
1257    case GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER:
1258    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER:
1259       _mesa_program_resource_prop(shProg, res, index,
1260                                   GL_REFERENCED_BY_COMPUTE_SHADER, params,
1261                                   caller);
1262       return;
1263    default:
1264       _mesa_error(ctx, GL_INVALID_ENUM,
1265                   "%s(pname 0x%x (%s))", caller, pname,
1266                   _mesa_enum_to_string(pname));
1267       return;
1268    }
1269 }
1270
1271
1272 void GLAPIENTRY
1273 _mesa_GetActiveUniformBlockiv(GLuint program,
1274                               GLuint uniformBlockIndex,
1275                               GLenum pname,
1276                               GLint *params)
1277 {
1278    GET_CURRENT_CONTEXT(ctx);
1279    struct gl_shader_program *shProg;
1280
1281    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1282       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1283       return;
1284    }
1285
1286    shProg = _mesa_lookup_shader_program_err(ctx, program,
1287                                             "glGetActiveUniformBlockiv");
1288    if (!shProg)
1289       return;
1290
1291    mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params,
1292                  "glGetActiveUniformBlockiv");
1293 }
1294
1295 void GLAPIENTRY
1296 _mesa_GetActiveUniformBlockName(GLuint program,
1297                                 GLuint uniformBlockIndex,
1298                                 GLsizei bufSize,
1299                                 GLsizei *length,
1300                                 GLchar *uniformBlockName)
1301 {
1302    GET_CURRENT_CONTEXT(ctx);
1303    struct gl_shader_program *shProg;
1304
1305    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1306       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1307       return;
1308    }
1309
1310    if (bufSize < 0) {
1311       _mesa_error(ctx, GL_INVALID_VALUE,
1312                   "glGetActiveUniformBlockName(bufSize %d < 0)",
1313                   bufSize);
1314       return;
1315    }
1316
1317    shProg = _mesa_lookup_shader_program_err(ctx, program,
1318                                             "glGetActiveUniformBlockiv");
1319    if (!shProg)
1320       return;
1321
1322    if (uniformBlockName)
1323       _mesa_get_program_resource_name(shProg, GL_UNIFORM_BLOCK,
1324                                       uniformBlockIndex, bufSize, length,
1325                                       uniformBlockName,
1326                                       "glGetActiveUniformBlockName");
1327 }
1328
1329 void GLAPIENTRY
1330 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex,
1331                            GLsizei bufSize, GLsizei *length,
1332                            GLchar *uniformName)
1333 {
1334    GET_CURRENT_CONTEXT(ctx);
1335    struct gl_shader_program *shProg;
1336
1337    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1338       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName");
1339       return;
1340    }
1341
1342    if (bufSize < 0) {
1343       _mesa_error(ctx, GL_INVALID_VALUE,
1344                   "glGetActiveUniformName(bufSize %d < 0)",
1345                   bufSize);
1346       return;
1347    }
1348
1349    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName");
1350
1351    if (!shProg)
1352       return;
1353
1354    _mesa_get_program_resource_name(shProg, GL_UNIFORM, uniformIndex, bufSize,
1355                                    length, uniformName, "glGetActiveUniformName");
1356 }
1357
1358 void GLAPIENTRY
1359 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex,
1360                                      GLenum pname, GLint *params)
1361 {
1362    GET_CURRENT_CONTEXT(ctx);
1363    struct gl_shader_program *shProg;
1364
1365    if (!ctx->Extensions.ARB_shader_atomic_counters) {
1366       _mesa_error(ctx, GL_INVALID_OPERATION,
1367                   "glGetActiveAtomicCounterBufferiv");
1368       return;
1369    }
1370
1371    shProg = _mesa_lookup_shader_program_err(ctx, program,
1372                                             "glGetActiveAtomicCounterBufferiv");
1373    if (!shProg)
1374       return;
1375
1376    mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params,
1377                  "glGetActiveAtomicCounterBufferiv");
1378 }
1379
1380 void GLAPIENTRY
1381 _mesa_Uniform1d(GLint location, GLdouble v0)
1382 {
1383    GET_CURRENT_CONTEXT(ctx);
1384    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 1);
1385 }
1386
1387 void GLAPIENTRY
1388 _mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1)
1389 {
1390    GET_CURRENT_CONTEXT(ctx);
1391    GLdouble v[2];
1392    v[0] = v0;
1393    v[1] = v1;
1394    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 2);
1395 }
1396
1397 void GLAPIENTRY
1398 _mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
1399 {
1400    GET_CURRENT_CONTEXT(ctx);
1401    GLdouble v[3];
1402    v[0] = v0;
1403    v[1] = v1;
1404    v[2] = v2;
1405    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 3);
1406 }
1407
1408 void GLAPIENTRY
1409 _mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2,
1410                 GLdouble v3)
1411 {
1412    GET_CURRENT_CONTEXT(ctx);
1413    GLdouble v[4];
1414    v[0] = v0;
1415    v[1] = v1;
1416    v[2] = v2;
1417    v[3] = v3;
1418    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 4);
1419 }
1420
1421 void GLAPIENTRY
1422 _mesa_Uniform1dv(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, 1);
1426 }
1427
1428 void GLAPIENTRY
1429 _mesa_Uniform2dv(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, 2);
1433 }
1434
1435 void GLAPIENTRY
1436 _mesa_Uniform3dv(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, 3);
1440 }
1441
1442 void GLAPIENTRY
1443 _mesa_Uniform4dv(GLint location, GLsizei count, const GLdouble * value)
1444 {
1445    GET_CURRENT_CONTEXT(ctx);
1446    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 4);
1447 }
1448
1449 void GLAPIENTRY
1450 _mesa_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,
1451                        const GLdouble * value)
1452 {
1453    GET_CURRENT_CONTEXT(ctx);
1454    _mesa_uniform_matrix(location, count, transpose, value,
1455                         ctx, ctx->_Shader->ActiveProgram, 2, 2, GLSL_TYPE_DOUBLE);
1456 }
1457
1458 void GLAPIENTRY
1459 _mesa_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,
1460                        const GLdouble * value)
1461 {
1462    GET_CURRENT_CONTEXT(ctx);
1463    _mesa_uniform_matrix(location, count, transpose, value,
1464                         ctx, ctx->_Shader->ActiveProgram, 3, 3, GLSL_TYPE_DOUBLE);
1465 }
1466
1467 void GLAPIENTRY
1468 _mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
1469                        const GLdouble * value)
1470 {
1471    GET_CURRENT_CONTEXT(ctx);
1472    _mesa_uniform_matrix(location, count, transpose, value,
1473                         ctx, ctx->_Shader->ActiveProgram, 4, 4, GLSL_TYPE_DOUBLE);
1474 }
1475
1476 void GLAPIENTRY
1477 _mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
1478                          const GLdouble *value)
1479 {
1480    GET_CURRENT_CONTEXT(ctx);
1481    _mesa_uniform_matrix(location, count, transpose, value,
1482                         ctx, ctx->_Shader->ActiveProgram, 2, 3, GLSL_TYPE_DOUBLE);
1483 }
1484
1485 void GLAPIENTRY
1486 _mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
1487                          const GLdouble *value)
1488 {
1489    GET_CURRENT_CONTEXT(ctx);
1490    _mesa_uniform_matrix(location, count, transpose, value,
1491                         ctx, ctx->_Shader->ActiveProgram, 3, 2, GLSL_TYPE_DOUBLE);
1492 }
1493
1494 void GLAPIENTRY
1495 _mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
1496                          const GLdouble *value)
1497 {
1498    GET_CURRENT_CONTEXT(ctx);
1499    _mesa_uniform_matrix(location, count, transpose, value,
1500                         ctx, ctx->_Shader->ActiveProgram, 2, 4, GLSL_TYPE_DOUBLE);
1501 }
1502
1503 void GLAPIENTRY
1504 _mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
1505                          const GLdouble *value)
1506 {
1507    GET_CURRENT_CONTEXT(ctx);
1508    _mesa_uniform_matrix(location, count, transpose, value,
1509                         ctx, ctx->_Shader->ActiveProgram, 4, 2, GLSL_TYPE_DOUBLE);
1510 }
1511
1512 void GLAPIENTRY
1513 _mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
1514                          const GLdouble *value)
1515 {
1516    GET_CURRENT_CONTEXT(ctx);
1517    _mesa_uniform_matrix(location, count, transpose, value,
1518                         ctx, ctx->_Shader->ActiveProgram, 3, 4, GLSL_TYPE_DOUBLE);
1519 }
1520
1521 void GLAPIENTRY
1522 _mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
1523                          const GLdouble *value)
1524 {
1525    GET_CURRENT_CONTEXT(ctx);
1526    _mesa_uniform_matrix(location, count, transpose, value,
1527                         ctx, ctx->_Shader->ActiveProgram, 4, 3, GLSL_TYPE_DOUBLE);
1528 }
1529
1530 void GLAPIENTRY
1531 _mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0)
1532 {
1533    GET_CURRENT_CONTEXT(ctx);
1534    struct gl_shader_program *shProg =
1535       _mesa_lookup_shader_program_err(ctx, program,
1536             "glProgramUniform1d");
1537    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_DOUBLE, 1);
1538 }
1539
1540 void GLAPIENTRY
1541 _mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
1542 {
1543    GET_CURRENT_CONTEXT(ctx);
1544    GLdouble v[2];
1545    struct gl_shader_program *shProg;
1546    v[0] = v0;
1547    v[1] = v1;
1548    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d");
1549    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 2);
1550 }
1551
1552 void GLAPIENTRY
1553 _mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1554                        GLdouble v2)
1555 {
1556    GET_CURRENT_CONTEXT(ctx);
1557    GLdouble v[3];
1558    struct gl_shader_program *shProg;
1559    v[0] = v0;
1560    v[1] = v1;
1561    v[2] = v2;
1562    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d");
1563    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 3);
1564 }
1565
1566 void GLAPIENTRY
1567 _mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1568                        GLdouble v2, GLdouble v3)
1569 {
1570    GET_CURRENT_CONTEXT(ctx);
1571    GLdouble v[4];
1572    struct gl_shader_program *shProg;
1573    v[0] = v0;
1574    v[1] = v1;
1575    v[2] = v2;
1576    v[3] = v3;
1577    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d");
1578    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 4);
1579 }
1580
1581 void GLAPIENTRY
1582 _mesa_ProgramUniform1dv(GLuint program, GLint location, GLsizei count,
1583                         const GLdouble * value)
1584 {
1585    GET_CURRENT_CONTEXT(ctx);
1586    struct gl_shader_program *shProg =
1587       _mesa_lookup_shader_program_err(ctx, program,
1588             "glProgramUniform1dv");
1589    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 1);
1590 }
1591
1592 void GLAPIENTRY
1593 _mesa_ProgramUniform2dv(GLuint program, GLint location, GLsizei count,
1594                         const GLdouble * value)
1595 {
1596    GET_CURRENT_CONTEXT(ctx);
1597    struct gl_shader_program *shProg =
1598       _mesa_lookup_shader_program_err(ctx, program,
1599             "glProgramUniform2dv");
1600    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 2);
1601 }
1602
1603 void GLAPIENTRY
1604 _mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count,
1605                         const GLdouble * value)
1606 {
1607    GET_CURRENT_CONTEXT(ctx);
1608    struct gl_shader_program *shProg =
1609       _mesa_lookup_shader_program_err(ctx, program,
1610             "glProgramUniform3dv");
1611    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 3);
1612 }
1613
1614 void GLAPIENTRY
1615 _mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count,
1616                         const GLdouble * value)
1617 {
1618    GET_CURRENT_CONTEXT(ctx);
1619    struct gl_shader_program *shProg =
1620       _mesa_lookup_shader_program_err(ctx, program,
1621             "glProgramUniform4dv");
1622    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 4);
1623 }
1624
1625 void GLAPIENTRY
1626 _mesa_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count,
1627                               GLboolean transpose, const GLdouble * value)
1628 {
1629    GET_CURRENT_CONTEXT(ctx);
1630    struct gl_shader_program *shProg =
1631       _mesa_lookup_shader_program_err(ctx, program,
1632             "glProgramUniformMatrix2dv");
1633    _mesa_uniform_matrix(location, count, transpose, value,
1634                         ctx, shProg, 2, 2, GLSL_TYPE_DOUBLE);
1635 }
1636
1637 void GLAPIENTRY
1638 _mesa_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count,
1639                               GLboolean transpose, const GLdouble * value)
1640 {
1641    GET_CURRENT_CONTEXT(ctx);
1642    struct gl_shader_program *shProg =
1643       _mesa_lookup_shader_program_err(ctx, program,
1644             "glProgramUniformMatrix3dv");
1645    _mesa_uniform_matrix(location, count, transpose, value,
1646                         ctx, shProg, 3, 3, GLSL_TYPE_DOUBLE);
1647 }
1648
1649 void GLAPIENTRY
1650 _mesa_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count,
1651                               GLboolean transpose, const GLdouble * value)
1652 {
1653    GET_CURRENT_CONTEXT(ctx);
1654    struct gl_shader_program *shProg =
1655       _mesa_lookup_shader_program_err(ctx, program,
1656             "glProgramUniformMatrix4dv");
1657    _mesa_uniform_matrix(location, count, transpose, value,
1658                         ctx, shProg, 4, 4, GLSL_TYPE_DOUBLE);
1659 }
1660
1661 void GLAPIENTRY
1662 _mesa_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count,
1663                                 GLboolean transpose, const GLdouble * value)
1664 {
1665    GET_CURRENT_CONTEXT(ctx);
1666    struct gl_shader_program *shProg =
1667       _mesa_lookup_shader_program_err(ctx, program,
1668             "glProgramUniformMatrix2x3dv");
1669    _mesa_uniform_matrix(location, count, transpose, value,
1670                         ctx, shProg, 2, 3, GLSL_TYPE_DOUBLE);
1671 }
1672
1673 void GLAPIENTRY
1674 _mesa_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count,
1675                                 GLboolean transpose, const GLdouble * value)
1676 {
1677    GET_CURRENT_CONTEXT(ctx);
1678    struct gl_shader_program *shProg =
1679       _mesa_lookup_shader_program_err(ctx, program,
1680             "glProgramUniformMatrix3x2dv");
1681    _mesa_uniform_matrix(location, count, transpose, value,
1682                         ctx, shProg, 3, 2, GLSL_TYPE_DOUBLE);
1683 }
1684
1685 void GLAPIENTRY
1686 _mesa_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count,
1687                                 GLboolean transpose, const GLdouble * value)
1688 {
1689    GET_CURRENT_CONTEXT(ctx);
1690    struct gl_shader_program *shProg =
1691       _mesa_lookup_shader_program_err(ctx, program,
1692             "glProgramUniformMatrix2x4dv");
1693    _mesa_uniform_matrix(location, count, transpose, value,
1694                         ctx, shProg, 2, 4, GLSL_TYPE_DOUBLE);
1695 }
1696
1697 void GLAPIENTRY
1698 _mesa_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count,
1699                                 GLboolean transpose, const GLdouble * value)
1700 {
1701    GET_CURRENT_CONTEXT(ctx);
1702    struct gl_shader_program *shProg =
1703       _mesa_lookup_shader_program_err(ctx, program,
1704             "glProgramUniformMatrix4x2dv");
1705    _mesa_uniform_matrix(location, count, transpose, value,
1706                         ctx, shProg, 4, 2, GLSL_TYPE_DOUBLE);
1707 }
1708
1709 void GLAPIENTRY
1710 _mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count,
1711                                 GLboolean transpose, const GLdouble * value)
1712 {
1713    GET_CURRENT_CONTEXT(ctx);
1714    struct gl_shader_program *shProg =
1715       _mesa_lookup_shader_program_err(ctx, program,
1716             "glProgramUniformMatrix3x4dv");
1717    _mesa_uniform_matrix(location, count, transpose, value,
1718                         ctx, shProg, 3, 4, GLSL_TYPE_DOUBLE);
1719 }
1720
1721 void GLAPIENTRY
1722 _mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count,
1723                                 GLboolean transpose, const GLdouble * value)
1724 {
1725    GET_CURRENT_CONTEXT(ctx);
1726    struct gl_shader_program *shProg =
1727       _mesa_lookup_shader_program_err(ctx, program,
1728             "glProgramUniformMatrix4x3dv");
1729    _mesa_uniform_matrix(location, count, transpose, value,
1730                         ctx, shProg, 4, 3, GLSL_TYPE_DOUBLE);
1731 }
1732
1733 void GLAPIENTRY
1734 _mesa_Uniform1i64ARB(GLint location, GLint64 v0)
1735 {
1736    GET_CURRENT_CONTEXT(ctx);
1737    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 1);
1738 }
1739
1740 void GLAPIENTRY
1741 _mesa_Uniform2i64ARB(GLint location, GLint64 v0, GLint64 v1)
1742 {
1743    GET_CURRENT_CONTEXT(ctx);
1744    int64_t v[2];
1745    v[0] = v0;
1746    v[1] = v1;
1747    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 2);
1748 }
1749
1750 void GLAPIENTRY
1751 _mesa_Uniform3i64ARB(GLint location, GLint64 v0, GLint64 v1, GLint64 v2)
1752 {
1753    GET_CURRENT_CONTEXT(ctx);
1754    int64_t v[3];
1755    v[0] = v0;
1756    v[1] = v1;
1757    v[2] = v2;
1758    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 3);
1759 }
1760
1761 void GLAPIENTRY
1762 _mesa_Uniform4i64ARB(GLint location,  GLint64 v0, GLint64 v1, GLint64 v2, GLint64 v3)
1763 {
1764    GET_CURRENT_CONTEXT(ctx);
1765    int64_t v[4];
1766    v[0] = v0;
1767    v[1] = v1;
1768    v[2] = v2;
1769    v[3] = v3;
1770    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 4);
1771 }
1772
1773 void GLAPIENTRY
1774 _mesa_Uniform1i64vARB(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, 1);
1778 }
1779
1780 void GLAPIENTRY
1781 _mesa_Uniform2i64vARB(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, 2);
1785 }
1786
1787 void GLAPIENTRY
1788 _mesa_Uniform3i64vARB(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, 3);
1792 }
1793
1794 void GLAPIENTRY
1795 _mesa_Uniform4i64vARB(GLint location,  GLsizei count, const GLint64 *value)
1796 {
1797    GET_CURRENT_CONTEXT(ctx);
1798    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 4);
1799 }
1800
1801 void GLAPIENTRY
1802 _mesa_Uniform1ui64ARB(GLint location,  GLuint64 v0)
1803 {
1804    GET_CURRENT_CONTEXT(ctx);
1805    _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 1);
1806 }
1807
1808 void GLAPIENTRY
1809 _mesa_Uniform2ui64ARB(GLint location,  GLuint64 v0, GLuint64 v1)
1810 {
1811    GET_CURRENT_CONTEXT(ctx);
1812    uint64_t v[2];
1813    v[0] = v0;
1814    v[1] = v1;
1815    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 2);
1816 }
1817
1818 void GLAPIENTRY
1819 _mesa_Uniform3ui64ARB(GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2)
1820 {
1821    GET_CURRENT_CONTEXT(ctx);
1822    uint64_t v[3];
1823    v[0] = v0;
1824    v[1] = v1;
1825    v[2] = v2;
1826    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 3);
1827 }
1828
1829 void GLAPIENTRY
1830 _mesa_Uniform4ui64ARB(GLint location,  GLuint64 v0, GLuint64 v1, GLuint64 v2, GLuint64 v3)
1831 {
1832    GET_CURRENT_CONTEXT(ctx);
1833    uint64_t v[4];
1834    v[0] = v0;
1835    v[1] = v1;
1836    v[2] = v2;
1837    v[3] = v3;
1838    _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 4);
1839 }
1840
1841 void GLAPIENTRY
1842 _mesa_Uniform1ui64vARB(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, 1);
1846 }
1847
1848 void GLAPIENTRY
1849 _mesa_Uniform2ui64vARB(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, 2);
1853 }
1854
1855 void GLAPIENTRY
1856 _mesa_Uniform3ui64vARB(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, 3);
1860 }
1861
1862 void GLAPIENTRY
1863 _mesa_Uniform4ui64vARB(GLint location,  GLsizei count, const GLuint64 *value)
1864 {
1865    GET_CURRENT_CONTEXT(ctx);
1866    _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 4);
1867 }
1868
1869 /* DSA entrypoints */
1870 void GLAPIENTRY
1871 _mesa_ProgramUniform1i64ARB(GLuint program, GLint location, GLint64 v0)
1872 {
1873    GET_CURRENT_CONTEXT(ctx);
1874    struct gl_shader_program *shProg =
1875       _mesa_lookup_shader_program_err(ctx, program,
1876             "glProgramUniform1i64ARB");
1877    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_INT64, 1);
1878 }
1879
1880 void GLAPIENTRY
1881 _mesa_ProgramUniform2i64ARB(GLuint program, GLint location, GLint64 v0, GLint64 v1)
1882 {
1883    GET_CURRENT_CONTEXT(ctx);
1884    struct gl_shader_program *shProg =
1885       _mesa_lookup_shader_program_err(ctx, program,
1886                                       "glProgramUniform2i64ARB");
1887    int64_t v[2];
1888    v[0] = v0;
1889    v[1] = v1;
1890    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 2);
1891 }
1892
1893 void GLAPIENTRY
1894 _mesa_ProgramUniform3i64ARB(GLuint program, GLint location, GLint64 v0, GLint64 v1, GLint64 v2)
1895 {
1896    GET_CURRENT_CONTEXT(ctx);
1897    struct gl_shader_program *shProg =
1898       _mesa_lookup_shader_program_err(ctx, program,
1899                                       "glProgramUniform3i64ARB");
1900    int64_t v[3];
1901    v[0] = v0;
1902    v[1] = v1;
1903    v[2] = v2;
1904    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 3);
1905 }
1906
1907 void GLAPIENTRY
1908 _mesa_ProgramUniform4i64ARB(GLuint program, GLint location,  GLint64 v0, GLint64 v1, GLint64 v2, GLint64 v3)
1909 {
1910    GET_CURRENT_CONTEXT(ctx);
1911    struct gl_shader_program *shProg =
1912       _mesa_lookup_shader_program_err(ctx, program,
1913                                       "glProgramUniform4i64ARB");
1914    int64_t v[4];
1915    v[0] = v0;
1916    v[1] = v1;
1917    v[2] = v2;
1918    v[3] = v3;
1919    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 4);
1920 }
1921
1922 void GLAPIENTRY
1923 _mesa_ProgramUniform1i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value)
1924 {
1925    GET_CURRENT_CONTEXT(ctx);
1926    struct gl_shader_program *shProg =
1927       _mesa_lookup_shader_program_err(ctx, program,
1928                                       "glProgramUniform1i64vARB");
1929    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 1);
1930 }
1931
1932 void GLAPIENTRY
1933 _mesa_ProgramUniform2i64vARB(GLuint program, GLint location,  GLsizei count, const GLint64 *value)
1934 {
1935    GET_CURRENT_CONTEXT(ctx);
1936    struct gl_shader_program *shProg =
1937       _mesa_lookup_shader_program_err(ctx, program,
1938                                       "glProgramUniform2i64vARB");
1939    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 2);
1940 }
1941
1942 void GLAPIENTRY
1943 _mesa_ProgramUniform3i64vARB(GLuint program, GLint location,  GLsizei count, const GLint64 *value)
1944 {
1945    GET_CURRENT_CONTEXT(ctx);
1946    struct gl_shader_program *shProg =
1947       _mesa_lookup_shader_program_err(ctx, program,
1948                                       "glProgramUniform3i64vARB");
1949    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 3);
1950 }
1951
1952 void GLAPIENTRY
1953 _mesa_ProgramUniform4i64vARB(GLuint program, GLint location,  GLsizei count, const GLint64 *value)
1954 {
1955    GET_CURRENT_CONTEXT(ctx);
1956    struct gl_shader_program *shProg =
1957       _mesa_lookup_shader_program_err(ctx, program,
1958                                       "glProgramUniform4i64vARB");
1959    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 4);
1960 }
1961
1962 void GLAPIENTRY
1963 _mesa_ProgramUniform1ui64ARB(GLuint program, GLint location,  GLuint64 v0)
1964 {
1965    GET_CURRENT_CONTEXT(ctx);
1966    struct gl_shader_program *shProg =
1967       _mesa_lookup_shader_program_err(ctx, program,
1968                                       "glProgramUniform1ui64ARB");
1969    _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_UINT64, 1);
1970 }
1971
1972 void GLAPIENTRY
1973 _mesa_ProgramUniform2ui64ARB(GLuint program, GLint location,  GLuint64 v0, GLuint64 v1)
1974 {
1975    GET_CURRENT_CONTEXT(ctx);
1976    struct gl_shader_program *shProg =
1977       _mesa_lookup_shader_program_err(ctx, program,
1978                                       "glProgramUniform2ui64ARB");
1979    uint64_t v[2];
1980    v[0] = v0;
1981    v[1] = v1;
1982    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 2);
1983 }
1984
1985 void GLAPIENTRY
1986 _mesa_ProgramUniform3ui64ARB(GLuint program, GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2)
1987 {
1988    GET_CURRENT_CONTEXT(ctx);
1989    struct gl_shader_program *shProg =
1990       _mesa_lookup_shader_program_err(ctx, program,
1991                                       "glProgramUniform3ui64ARB");
1992    uint64_t v[3];
1993    v[0] = v0;
1994    v[1] = v1;
1995    v[2] = v2;
1996    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 3);
1997 }
1998
1999 void GLAPIENTRY
2000 _mesa_ProgramUniform4ui64ARB(GLuint program, GLint location,  GLuint64 v0, GLuint64 v1, GLuint64 v2, GLuint64 v3)
2001 {
2002    GET_CURRENT_CONTEXT(ctx);
2003    struct gl_shader_program *shProg =
2004       _mesa_lookup_shader_program_err(ctx, program,
2005                                       "glProgramUniform4ui64ARB");
2006    uint64_t v[4];
2007    v[0] = v0;
2008    v[1] = v1;
2009    v[2] = v2;
2010    v[3] = v3;
2011    _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 4);
2012 }
2013
2014 void GLAPIENTRY
2015 _mesa_ProgramUniform1ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2016 {
2017    GET_CURRENT_CONTEXT(ctx);
2018    struct gl_shader_program *shProg =
2019       _mesa_lookup_shader_program_err(ctx, program,
2020                                       "glProgramUniform1ui64vARB");
2021    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 1);
2022 }
2023
2024 void GLAPIENTRY
2025 _mesa_ProgramUniform2ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2026 {
2027    GET_CURRENT_CONTEXT(ctx);
2028    struct gl_shader_program *shProg =
2029       _mesa_lookup_shader_program_err(ctx, program,
2030                                       "glProgramUniform2ui64vARB");
2031    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 2);
2032 }
2033
2034 void GLAPIENTRY
2035 _mesa_ProgramUniform3ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2036 {
2037    GET_CURRENT_CONTEXT(ctx);
2038    struct gl_shader_program *shProg =
2039       _mesa_lookup_shader_program_err(ctx, program,
2040                                       "glProgramUniform3ui64vARB");
2041    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 3);
2042 }
2043
2044 void GLAPIENTRY
2045 _mesa_ProgramUniform4ui64vARB(GLuint program, GLint location,  GLsizei count, const GLuint64 *value)
2046 {
2047    GET_CURRENT_CONTEXT(ctx);
2048    struct gl_shader_program *shProg =
2049       _mesa_lookup_shader_program_err(ctx, program,
2050                                       "glProgramUniform4ui64vARB");
2051    _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 4);
2052 }