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
 900 GLint GLAPIENTRY
 901 _mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name)
 902 {
 903    struct gl_shader_program *shProg;
 904
 905    GET_CURRENT_CONTEXT(ctx);
 906
 907    shProg = _mesa_lookup_shader_program_err(ctx, programObj,
 908                                             "glGetUniformLocation");
 909    if (!shProg)
 910       return -1;
 911
 912    /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says:
 913     *
 914     *     "If program has not been successfully linked, the error
 915     *     INVALID_OPERATION is generated."
 916     */
 917    if (shProg->data->LinkStatus == GL_FALSE) {
 918       _mesa_error(ctx, GL_INVALID_OPERATION,
 919                   "glGetUniformLocation(program not linked)");
 920       return -1;
 921    }
 922
 923    return _mesa_program_resource_location(shProg, GL_UNIFORM, name);
 924 }
 925
 926 GLuint GLAPIENTRY
 927 _mesa_GetUniformBlockIndex(GLuint program,
 928                            const GLchar *uniformBlockName)
 929 {
 930    GET_CURRENT_CONTEXT(ctx);
 931    struct gl_shader_program *shProg;
 932
 933    if (!ctx->Extensions.ARB_uniform_buffer_object) {
 934       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex");
 935       return GL_INVALID_INDEX;
 936    }
 937
 938    shProg = _mesa_lookup_shader_program_err(ctx, program,
 939                                             "glGetUniformBlockIndex");
 940    if (!shProg)
 941       return GL_INVALID_INDEX;
 942
 943    struct gl_program_resource *res =
 944       _mesa_program_resource_find_name(shProg, GL_UNIFORM_BLOCK,
 945                                        uniformBlockName, NULL);
 946    if (!res)
 947       return GL_INVALID_INDEX;
 948
 949    return _mesa_program_resource_index(shProg, res);
 950 }
 951
 952 void GLAPIENTRY
 953 _mesa_GetUniformIndices(GLuint program,
 954                         GLsizei uniformCount,
 955                         const GLchar * const *uniformNames,
 956                         GLuint *uniformIndices)
 957 {
 958    GET_CURRENT_CONTEXT(ctx);
 959    GLsizei i;
 960    struct gl_shader_program *shProg;
 961
 962    if (!ctx->Extensions.ARB_uniform_buffer_object) {
 963       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices");
 964       return;
 965    }
 966
 967    shProg = _mesa_lookup_shader_program_err(ctx, program,
 968                                             "glGetUniformIndices");
 969    if (!shProg)
 970       return;
 971
 972    if (uniformCount < 0) {
 973       _mesa_error(ctx, GL_INVALID_VALUE,
 974                   "glGetUniformIndices(uniformCount < 0)");
 975       return;
 976    }
 977
 978    for (i = 0; i < uniformCount; i++) {
 979       struct gl_program_resource *res =
 980          _mesa_program_resource_find_name(shProg, GL_UNIFORM, uniformNames[i],
 981                                           NULL);
 982       uniformIndices[i] = _mesa_program_resource_index(shProg, res);
 983    }
 984 }
 985
 986 void GLAPIENTRY
 987 _mesa_UniformBlockBinding(GLuint program,
 988                           GLuint uniformBlockIndex,
 989                           GLuint uniformBlockBinding)
 990 {
 991    GET_CURRENT_CONTEXT(ctx);
 992    struct gl_shader_program *shProg;
 993
 994    if (!ctx->Extensions.ARB_uniform_buffer_object) {
 995       _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding");
 996       return;
 997    }
 998
 999    shProg = _mesa_lookup_shader_program_err(ctx, program,
1000                                             "glUniformBlockBinding");
1001    if (!shProg)
1002       return;
1003
1004    if (uniformBlockIndex >= shProg->data->NumUniformBlocks) {
1005       _mesa_error(ctx, GL_INVALID_VALUE,
1006                   "glUniformBlockBinding(block index %u >= %u)",
1007                   uniformBlockIndex, shProg->data->NumUniformBlocks);
1008       return;
1009    }
1010
1011    if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) {
1012       _mesa_error(ctx, GL_INVALID_VALUE,
1013                   "glUniformBlockBinding(block binding %u >= %u)",
1014                   uniformBlockBinding, ctx->Const.MaxUniformBufferBindings);
1015       return;
1016    }
1017
1018    if (shProg->data->UniformBlocks[uniformBlockIndex].Binding !=
1019        uniformBlockBinding) {
1020
1021       FLUSH_VERTICES(ctx, 0);
1022       ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
1023
1024       shProg->data->UniformBlocks[uniformBlockIndex].Binding =
1025          uniformBlockBinding;
1026    }
1027 }
1028
1029 void GLAPIENTRY
1030 _mesa_ShaderStorageBlockBinding(GLuint program,
1031                                 GLuint shaderStorageBlockIndex,
1032                                 GLuint shaderStorageBlockBinding)
1033 {
1034    GET_CURRENT_CONTEXT(ctx);
1035    struct gl_shader_program *shProg;
1036
1037    if (!ctx->Extensions.ARB_shader_storage_buffer_object) {
1038       _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderStorageBlockBinding");
1039       return;
1040    }
1041
1042    shProg = _mesa_lookup_shader_program_err(ctx, program,
1043                                             "glShaderStorageBlockBinding");
1044    if (!shProg)
1045       return;
1046
1047    if (shaderStorageBlockIndex >= shProg->data->NumShaderStorageBlocks) {
1048       _mesa_error(ctx, GL_INVALID_VALUE,
1049                   "glShaderStorageBlockBinding(block index %u >= %u)",
1050                   shaderStorageBlockIndex,
1051                   shProg->data->NumShaderStorageBlocks);
1052       return;
1053    }
1054
1055    if (shaderStorageBlockBinding >= ctx->Const.MaxShaderStorageBufferBindings) {
1056       _mesa_error(ctx, GL_INVALID_VALUE,
1057                   "glShaderStorageBlockBinding(block binding %u >= %u)",
1058                   shaderStorageBlockBinding,
1059                   ctx->Const.MaxShaderStorageBufferBindings);
1060       return;
1061    }
1062
1063    if (shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding !=
1064        shaderStorageBlockBinding) {
1065
1066       FLUSH_VERTICES(ctx, 0);
1067       ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer;
1068
1069       shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding =
1070          shaderStorageBlockBinding;
1071    }
1072 }
1073
1074 /**
1075  * Generic program resource property query.
1076  */
1077 static void
1078 mesa_bufferiv(struct gl_shader_program *shProg, GLenum type,
1079               GLuint index, GLenum pname, GLint *params, const char *caller)
1080 {
1081    GET_CURRENT_CONTEXT(ctx);
1082    struct gl_program_resource *res =
1083       _mesa_program_resource_find_index(shProg, type, index);
1084
1085    if (!res) {
1086       _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index);
1087       return;
1088    }
1089
1090    switch (pname) {
1091    case GL_UNIFORM_BLOCK_BINDING:
1092    case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1093       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING,
1094                                   params, caller);
1095       return;
1096    case GL_UNIFORM_BLOCK_DATA_SIZE:
1097    case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
1098       _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE,
1099                                   params, caller);
1100       return;
1101    case GL_UNIFORM_BLOCK_NAME_LENGTH:
1102       _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH,
1103                                   params, caller);
1104       return;
1105    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
1106    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
1107       _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES,
1108                                   params, caller);
1109       return;
1110    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
1111    case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
1112       _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES,
1113                                   params, caller);
1114       return;
1115    case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
1116    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
1117       _mesa_program_resource_prop(shProg, res, index,
1118                                   GL_REFERENCED_BY_VERTEX_SHADER, params,
1119                                   caller);
1120       return;
1121
1122    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER:
1123    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
1124       _mesa_program_resource_prop(shProg, res, index,
1125                                   GL_REFERENCED_BY_TESS_CONTROL_SHADER, params,
1126                                   caller);
1127       return;
1128
1129    case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER:
1130    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
1131       _mesa_program_resource_prop(shProg, res, index,
1132                                   GL_REFERENCED_BY_TESS_EVALUATION_SHADER, params,
1133                                   caller);
1134       return;
1135
1136    case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
1137    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
1138       _mesa_program_resource_prop(shProg, res, index,
1139                                   GL_REFERENCED_BY_GEOMETRY_SHADER, params,
1140                                   caller);
1141       return;
1142    case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
1143    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
1144       _mesa_program_resource_prop(shProg, res, index,
1145                                   GL_REFERENCED_BY_FRAGMENT_SHADER, params,
1146                                   caller);
1147       return;
1148    case GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER:
1149    case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER:
1150       _mesa_program_resource_prop(shProg, res, index,
1151                                   GL_REFERENCED_BY_COMPUTE_SHADER, params,
1152                                   caller);
1153       return;
1154    default:
1155       _mesa_error(ctx, GL_INVALID_ENUM,
1156                   "%s(pname 0x%x (%s))", caller, pname,
1157                   _mesa_enum_to_string(pname));
1158       return;
1159    }
1160 }
1161
1162
1163 void GLAPIENTRY
1164 _mesa_GetActiveUniformBlockiv(GLuint program,
1165                               GLuint uniformBlockIndex,
1166                               GLenum pname,
1167                               GLint *params)
1168 {
1169    GET_CURRENT_CONTEXT(ctx);
1170    struct gl_shader_program *shProg;
1171
1172    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1173       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1174       return;
1175    }
1176
1177    shProg = _mesa_lookup_shader_program_err(ctx, program,
1178                                             "glGetActiveUniformBlockiv");
1179    if (!shProg)
1180       return;
1181
1182    mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params,
1183                  "glGetActiveUniformBlockiv");
1184 }
1185
1186 void GLAPIENTRY
1187 _mesa_GetActiveUniformBlockName(GLuint program,
1188                                 GLuint uniformBlockIndex,
1189                                 GLsizei bufSize,
1190                                 GLsizei *length,
1191                                 GLchar *uniformBlockName)
1192 {
1193    GET_CURRENT_CONTEXT(ctx);
1194    struct gl_shader_program *shProg;
1195
1196    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1197       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1198       return;
1199    }
1200
1201    if (bufSize < 0) {
1202       _mesa_error(ctx, GL_INVALID_VALUE,
1203                   "glGetActiveUniformBlockName(bufSize %d < 0)",
1204                   bufSize);
1205       return;
1206    }
1207
1208    shProg = _mesa_lookup_shader_program_err(ctx, program,
1209                                             "glGetActiveUniformBlockiv");
1210    if (!shProg)
1211       return;
1212
1213    if (uniformBlockName)
1214       _mesa_get_program_resource_name(shProg, GL_UNIFORM_BLOCK,
1215                                       uniformBlockIndex, bufSize, length,
1216                                       uniformBlockName,
1217                                       "glGetActiveUniformBlockName");
1218 }
1219
1220 void GLAPIENTRY
1221 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex,
1222                            GLsizei bufSize, GLsizei *length,
1223                            GLchar *uniformName)
1224 {
1225    GET_CURRENT_CONTEXT(ctx);
1226    struct gl_shader_program *shProg;
1227
1228    if (!ctx->Extensions.ARB_uniform_buffer_object) {
1229       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName");
1230       return;
1231    }
1232
1233    if (bufSize < 0) {
1234       _mesa_error(ctx, GL_INVALID_VALUE,
1235                   "glGetActiveUniformName(bufSize %d < 0)",
1236                   bufSize);
1237       return;
1238    }
1239
1240    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName");
1241
1242    if (!shProg)
1243       return;
1244
1245    _mesa_get_program_resource_name(shProg, GL_UNIFORM, uniformIndex, bufSize,
1246                                    length, uniformName, "glGetActiveUniformName");
1247 }
1248
1249 void GLAPIENTRY
1250 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex,
1251                                      GLenum pname, GLint *params)
1252 {
1253    GET_CURRENT_CONTEXT(ctx);
1254    struct gl_shader_program *shProg;
1255
1256    if (!ctx->Extensions.ARB_shader_atomic_counters) {
1257       _mesa_error(ctx, GL_INVALID_OPERATION,
1258                   "glGetActiveAtomicCounterBufferiv");
1259       return;
1260    }
1261
1262    shProg = _mesa_lookup_shader_program_err(ctx, program,
1263                                             "glGetActiveAtomicCounterBufferiv");
1264    if (!shProg)
1265       return;
1266
1267    mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params,
1268                  "glGetActiveAtomicCounterBufferiv");
1269 }
1270
1271 void GLAPIENTRY
1272 _mesa_Uniform1d(GLint location, GLdouble v0)
1273 {
1274    GET_CURRENT_CONTEXT(ctx);
1275    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1276 }
1277
1278 void GLAPIENTRY
1279 _mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1)
1280 {
1281    GET_CURRENT_CONTEXT(ctx);
1282    GLdouble v[2];
1283    v[0] = v0;
1284    v[1] = v1;
1285    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1286 }
1287
1288 void GLAPIENTRY
1289 _mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
1290 {
1291    GET_CURRENT_CONTEXT(ctx);
1292    GLdouble v[3];
1293    v[0] = v0;
1294    v[1] = v1;
1295    v[2] = v2;
1296    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1297 }
1298
1299 void GLAPIENTRY
1300 _mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2,
1301                 GLdouble v3)
1302 {
1303    GET_CURRENT_CONTEXT(ctx);
1304    GLdouble v[4];
1305    v[0] = v0;
1306    v[1] = v1;
1307    v[2] = v2;
1308    v[3] = v3;
1309    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1310 }
1311
1312 void GLAPIENTRY
1313 _mesa_Uniform1dv(GLint location, GLsizei count, const GLdouble * value)
1314 {
1315    GET_CURRENT_CONTEXT(ctx);
1316    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 1);
1317 }
1318
1319 void GLAPIENTRY
1320 _mesa_Uniform2dv(GLint location, GLsizei count, const GLdouble * value)
1321 {
1322    GET_CURRENT_CONTEXT(ctx);
1323    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 2);
1324 }
1325
1326 void GLAPIENTRY
1327 _mesa_Uniform3dv(GLint location, GLsizei count, const GLdouble * value)
1328 {
1329    GET_CURRENT_CONTEXT(ctx);
1330    _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 3);
1331 }
1332
1333 void GLAPIENTRY
1334 _mesa_Uniform4dv(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, 4);
1338 }
1339
1340 void GLAPIENTRY
1341 _mesa_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,
1342                        const GLdouble * value)
1343 {
1344    GET_CURRENT_CONTEXT(ctx);
1345    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1346                         2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1347 }
1348
1349 void GLAPIENTRY
1350 _mesa_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,
1351                        const GLdouble * value)
1352 {
1353    GET_CURRENT_CONTEXT(ctx);
1354    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1355                         3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1356 }
1357
1358 void GLAPIENTRY
1359 _mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
1360                        const GLdouble * value)
1361 {
1362    GET_CURRENT_CONTEXT(ctx);
1363    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1364                         4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1365 }
1366
1367 void GLAPIENTRY
1368 _mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
1369                          const GLdouble *value)
1370 {
1371    GET_CURRENT_CONTEXT(ctx);
1372    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1373                         2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1374 }
1375
1376 void GLAPIENTRY
1377 _mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
1378                          const GLdouble *value)
1379 {
1380    GET_CURRENT_CONTEXT(ctx);
1381    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1382                         3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1383 }
1384
1385 void GLAPIENTRY
1386 _mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
1387                          const GLdouble *value)
1388 {
1389    GET_CURRENT_CONTEXT(ctx);
1390    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1391                         2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1392 }
1393
1394 void GLAPIENTRY
1395 _mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
1396                          const GLdouble *value)
1397 {
1398    GET_CURRENT_CONTEXT(ctx);
1399    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1400                         4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1401 }
1402
1403 void GLAPIENTRY
1404 _mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
1405                          const GLdouble *value)
1406 {
1407    GET_CURRENT_CONTEXT(ctx);
1408    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1409                         3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1410 }
1411
1412 void GLAPIENTRY
1413 _mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
1414                          const GLdouble *value)
1415 {
1416    GET_CURRENT_CONTEXT(ctx);
1417    _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1418                         4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1419 }
1420
1421 void GLAPIENTRY
1422 _mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0)
1423 {
1424    GET_CURRENT_CONTEXT(ctx);
1425    struct gl_shader_program *shProg =
1426       _mesa_lookup_shader_program_err(ctx, program,
1427             "glProgramUniform1d");
1428    _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1429 }
1430
1431 void GLAPIENTRY
1432 _mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
1433 {
1434    GET_CURRENT_CONTEXT(ctx);
1435    GLdouble v[2];
1436    struct gl_shader_program *shProg;
1437    v[0] = v0;
1438    v[1] = v1;
1439    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d");
1440    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1441 }
1442
1443 void GLAPIENTRY
1444 _mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1445                        GLdouble v2)
1446 {
1447    GET_CURRENT_CONTEXT(ctx);
1448    GLdouble v[3];
1449    struct gl_shader_program *shProg;
1450    v[0] = v0;
1451    v[1] = v1;
1452    v[2] = v2;
1453    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d");
1454    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1455 }
1456
1457 void GLAPIENTRY
1458 _mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1459                        GLdouble v2, GLdouble v3)
1460 {
1461    GET_CURRENT_CONTEXT(ctx);
1462    GLdouble v[4];
1463    struct gl_shader_program *shProg;
1464    v[0] = v0;
1465    v[1] = v1;
1466    v[2] = v2;
1467    v[3] = v3;
1468    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d");
1469    _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1470 }
1471
1472 void GLAPIENTRY
1473 _mesa_ProgramUniform1dv(GLuint program, GLint location, GLsizei count,
1474                         const GLdouble * value)
1475 {
1476    GET_CURRENT_CONTEXT(ctx);
1477    struct gl_shader_program *shProg =
1478       _mesa_lookup_shader_program_err(ctx, program,
1479             "glProgramUniform1dv");
1480    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 1);
1481 }
1482
1483 void GLAPIENTRY
1484 _mesa_ProgramUniform2dv(GLuint program, GLint location, GLsizei count,
1485                         const GLdouble * value)
1486 {
1487    GET_CURRENT_CONTEXT(ctx);
1488    struct gl_shader_program *shProg =
1489       _mesa_lookup_shader_program_err(ctx, program,
1490             "glProgramUniform2dv");
1491    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 2);
1492 }
1493
1494 void GLAPIENTRY
1495 _mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count,
1496                         const GLdouble * value)
1497 {
1498    GET_CURRENT_CONTEXT(ctx);
1499    struct gl_shader_program *shProg =
1500       _mesa_lookup_shader_program_err(ctx, program,
1501             "glProgramUniform3dv");
1502    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 3);
1503 }
1504
1505 void GLAPIENTRY
1506 _mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count,
1507                         const GLdouble * value)
1508 {
1509    GET_CURRENT_CONTEXT(ctx);
1510    struct gl_shader_program *shProg =
1511       _mesa_lookup_shader_program_err(ctx, program,
1512             "glProgramUniform4dv");
1513    _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 4);
1514 }
1515
1516 void GLAPIENTRY
1517 _mesa_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count,
1518                               GLboolean transpose, const GLdouble * value)
1519 {
1520    GET_CURRENT_CONTEXT(ctx);
1521    struct gl_shader_program *shProg =
1522       _mesa_lookup_shader_program_err(ctx, program,
1523             "glProgramUniformMatrix2dv");
1524    _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1525 }
1526
1527 void GLAPIENTRY
1528 _mesa_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count,
1529                               GLboolean transpose, const GLdouble * value)
1530 {
1531    GET_CURRENT_CONTEXT(ctx);
1532    struct gl_shader_program *shProg =
1533       _mesa_lookup_shader_program_err(ctx, program,
1534             "glProgramUniformMatrix3dv");
1535    _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1536 }
1537
1538 void GLAPIENTRY
1539 _mesa_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count,
1540                               GLboolean transpose, const GLdouble * value)
1541 {
1542    GET_CURRENT_CONTEXT(ctx);
1543    struct gl_shader_program *shProg =
1544       _mesa_lookup_shader_program_err(ctx, program,
1545             "glProgramUniformMatrix4dv");
1546    _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1547 }
1548
1549 void GLAPIENTRY
1550 _mesa_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count,
1551                                 GLboolean transpose, const GLdouble * value)
1552 {
1553    GET_CURRENT_CONTEXT(ctx);
1554    struct gl_shader_program *shProg =
1555       _mesa_lookup_shader_program_err(ctx, program,
1556             "glProgramUniformMatrix2x3dv");
1557    _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1558 }
1559
1560 void GLAPIENTRY
1561 _mesa_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count,
1562                                 GLboolean transpose, const GLdouble * value)
1563 {
1564    GET_CURRENT_CONTEXT(ctx);
1565    struct gl_shader_program *shProg =
1566       _mesa_lookup_shader_program_err(ctx, program,
1567             "glProgramUniformMatrix3x2dv");
1568    _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1569 }
1570
1571 void GLAPIENTRY
1572 _mesa_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count,
1573                                 GLboolean transpose, const GLdouble * value)
1574 {
1575    GET_CURRENT_CONTEXT(ctx);
1576    struct gl_shader_program *shProg =
1577       _mesa_lookup_shader_program_err(ctx, program,
1578             "glProgramUniformMatrix2x4dv");
1579    _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1580 }
1581
1582 void GLAPIENTRY
1583 _mesa_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count,
1584                                 GLboolean transpose, const GLdouble * value)
1585 {
1586    GET_CURRENT_CONTEXT(ctx);
1587    struct gl_shader_program *shProg =
1588       _mesa_lookup_shader_program_err(ctx, program,
1589             "glProgramUniformMatrix4x2dv");
1590    _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1591 }
1592
1593 void GLAPIENTRY
1594 _mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count,
1595                                 GLboolean transpose, const GLdouble * value)
1596 {
1597    GET_CURRENT_CONTEXT(ctx);
1598    struct gl_shader_program *shProg =
1599       _mesa_lookup_shader_program_err(ctx, program,
1600             "glProgramUniformMatrix3x4dv");
1601    _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1602 }
1603
1604 void GLAPIENTRY
1605 _mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count,
1606                                 GLboolean transpose, const GLdouble * value)
1607 {
1608    GET_CURRENT_CONTEXT(ctx);
1609    struct gl_shader_program *shProg =
1610       _mesa_lookup_shader_program_err(ctx, program,
1611             "glProgramUniformMatrix4x3dv");
1612    _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1613 }