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