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