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 */
66void
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 */
114void
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 */
141void
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
149void 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
156void 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
166void 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
177void 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
190void 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
197void 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
207void 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
218void 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
230void 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
237void 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
244void 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
251void 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
258void 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
265void 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
272void 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
279void 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 **/
287void 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
297void 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
309void 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
323void 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
338void 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
348void 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
360void 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
374void 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
389void 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
400void 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
411void 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
422void 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
433void 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
444void 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
455void 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
466void 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 **/
479void 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
486void 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
496void 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
507void 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
519void 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
526void 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
533void 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
540void 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
549void 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
558void 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
567void 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
578void 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
588void 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
601void 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
616void 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
631void 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
642void 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
653void 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
664void 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
677void 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
688void 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
699void 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 */
714void 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
723void 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
732void 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
741void 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
750void 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
759void 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
770void 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
781void 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
792void 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
803void 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
814void 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
825void 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
837void 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
845void GLAPIENTRY
846_mesa_GetUniformfv(GLuint program, GLint location, GLfloat *params)
847{
848   _mesa_GetnUniformfvARB(program, location, INT_MAX, params);
849}
850
851
852void 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
860void GLAPIENTRY
861_mesa_GetUniformiv(GLuint program, GLint location, GLint *params)
862{
863   _mesa_GetnUniformivARB(program, location, INT_MAX, params);
864}
865
866
867/* GL3 */
868void 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
876void GLAPIENTRY
877_mesa_GetUniformuiv(GLuint program, GLint location, GLuint *params)
878{
879   _mesa_GetnUniformuivARB(program, location, INT_MAX, params);
880}
881
882
883/* GL4 */
884void 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
893void GLAPIENTRY
894_mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params)
895{
896   _mesa_GetnUniformdvARB(program, location, INT_MAX, params);
897}
898
899
900GLint 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
926GLuint 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
952void 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
986void 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
1029void 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 */
1077static void
1078mesa_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
1163void 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
1186void 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
1220void 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
1249void 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
1271void 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
1278void 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
1288void 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
1299void 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
1312void 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
1319void 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
1326void 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
1333void 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
1340void 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
1349void 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
1358void 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
1367void 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
1376void 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
1385void 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
1394void 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
1403void 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
1412void 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
1421void 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
1431void 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
1443void 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
1457void 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
1472void 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
1483void 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
1494void 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
1505void 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
1516void 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
1527void 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
1538void 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
1549void 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
1560void 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
1571void 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
1582void 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
1593void 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
1604void 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}
1614