Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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