projects / mesa.git / blob
? search:


47f80ce2001359dd005f50b20c90bb98d1cacd49
[mesa.git] / src / mesa / main / uniforms.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 2004-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009-2010 VMware, Inc. All Rights Reserved.
6 * Copyright © 2010 Intel Corporation
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 * OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27 /**
28 * \file uniforms.c
29 * Functions related to GLSL uniform variables.
30 * \author Brian Paul
31 */
32
33 /**
34 * XXX things to do:
35 * 1. Check that the right error code is generated for all _mesa_error() calls.
36 * 2. Insert FLUSH_VERTICES calls in various places
37 */
38
39 #include "main/glheader.h"
40 #include "main/context.h"
41 #include "main/dispatch.h"
42 #include "main/shaderapi.h"
43 #include "main/shaderobj.h"
44 #include "main/uniforms.h"
45 #include "main/enums.h"
46 #include "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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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, GLSL_TYPE_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 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_DOUBLE, params);
892 }
893
894 void GLAPIENTRY
895 _mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params)
896 {
897 _mesa_GetnUniformdvARB(program, location, INT_MAX, params);
898 }
899
900
901 GLint GLAPIENTRY
902 _mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name)
903 {
904 struct gl_shader_program *shProg;
905
906 GET_CURRENT_CONTEXT(ctx);
907
908 shProg = _mesa_lookup_shader_program_err(ctx, programObj,
909 "glGetUniformLocation");
910 if (!shProg)
911 return -1;
912
913 /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says:
914 *
915 * "If program has not been successfully linked, the error
916 * INVALID_OPERATION is generated."
917 */
918 if (shProg->LinkStatus == GL_FALSE) {
919 _mesa_error(ctx, GL_INVALID_OPERATION,
920 "glGetUniformLocation(program not linked)");
921 return -1;
922 }
923
924 return _mesa_program_resource_location(shProg, GL_UNIFORM, name);
925 }
926
927 GLuint GLAPIENTRY
928 _mesa_GetUniformBlockIndex(GLuint program,
929 const GLchar *uniformBlockName)
930 {
931 GET_CURRENT_CONTEXT(ctx);
932 struct gl_shader_program *shProg;
933
934 if (!ctx->Extensions.ARB_uniform_buffer_object) {
935 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex");
936 return GL_INVALID_INDEX;
937 }
938
939 shProg = _mesa_lookup_shader_program_err(ctx, program,
940 "glGetUniformBlockIndex");
941 if (!shProg)
942 return GL_INVALID_INDEX;
943
944 struct gl_program_resource *res =
945 _mesa_program_resource_find_name(shProg, GL_UNIFORM_BLOCK,
946 uniformBlockName, NULL);
947 if (!res)
948 return GL_INVALID_INDEX;
949
950 return _mesa_program_resource_index(shProg, res);
951 }
952
953 void GLAPIENTRY
954 _mesa_GetUniformIndices(GLuint program,
955 GLsizei uniformCount,
956 const GLchar * const *uniformNames,
957 GLuint *uniformIndices)
958 {
959 GET_CURRENT_CONTEXT(ctx);
960 GLsizei i;
961 struct gl_shader_program *shProg;
962
963 if (!ctx->Extensions.ARB_uniform_buffer_object) {
964 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices");
965 return;
966 }
967
968 shProg = _mesa_lookup_shader_program_err(ctx, program,
969 "glGetUniformIndices");
970 if (!shProg)
971 return;
972
973 if (uniformCount < 0) {
974 _mesa_error(ctx, GL_INVALID_VALUE,
975 "glGetUniformIndices(uniformCount < 0)");
976 return;
977 }
978
979 for (i = 0; i < uniformCount; i++) {
980 struct gl_program_resource *res =
981 _mesa_program_resource_find_name(shProg, GL_UNIFORM, uniformNames[i],
982 NULL);
983 uniformIndices[i] = _mesa_program_resource_index(shProg, res);
984 }
985 }
986
987 void GLAPIENTRY
988 _mesa_UniformBlockBinding(GLuint program,
989 GLuint uniformBlockIndex,
990 GLuint uniformBlockBinding)
991 {
992 GET_CURRENT_CONTEXT(ctx);
993 struct gl_shader_program *shProg;
994
995 if (!ctx->Extensions.ARB_uniform_buffer_object) {
996 _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding");
997 return;
998 }
999
1000 shProg = _mesa_lookup_shader_program_err(ctx, program,
1001 "glUniformBlockBinding");
1002 if (!shProg)
1003 return;
1004
1005 if (uniformBlockIndex >= shProg->NumUniformBlocks) {
1006 _mesa_error(ctx, GL_INVALID_VALUE,
1007 "glUniformBlockBinding(block index %u >= %u)",
1008 uniformBlockIndex, shProg->NumUniformBlocks);
1009 return;
1010 }
1011
1012 if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) {
1013 _mesa_error(ctx, GL_INVALID_VALUE,
1014 "glUniformBlockBinding(block binding %u >= %u)",
1015 uniformBlockBinding, ctx->Const.MaxUniformBufferBindings);
1016 return;
1017 }
1018
1019 if (shProg->UniformBlocks[uniformBlockIndex]->Binding !=
1020 uniformBlockBinding) {
1021 int i;
1022
1023 FLUSH_VERTICES(ctx, 0);
1024 ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
1025
1026 const int interface_block_index =
1027 shProg->UboInterfaceBlockIndex[uniformBlockIndex];
1028
1029 shProg->BufferInterfaceBlocks[interface_block_index].Binding =
1030 uniformBlockBinding;
1031
1032 for (i = 0; i < MESA_SHADER_STAGES; i++) {
1033 int stage_index =
1034 shProg->InterfaceBlockStageIndex[i][interface_block_index];
1035
1036 if (stage_index != -1) {
1037 struct gl_shader *sh = shProg->_LinkedShaders[i];
1038 sh->BufferInterfaceBlocks[stage_index].Binding = uniformBlockBinding;
1039 }
1040 }
1041 }
1042 }
1043
1044 void GLAPIENTRY
1045 _mesa_ShaderStorageBlockBinding(GLuint program,
1046 GLuint shaderStorageBlockIndex,
1047 GLuint shaderStorageBlockBinding)
1048 {
1049 GET_CURRENT_CONTEXT(ctx);
1050 struct gl_shader_program *shProg;
1051
1052 if (!ctx->Extensions.ARB_shader_storage_buffer_object) {
1053 _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderStorageBlockBinding");
1054 return;
1055 }
1056
1057 shProg = _mesa_lookup_shader_program_err(ctx, program,
1058 "glShaderStorageBlockBinding");
1059 if (!shProg)
1060 return;
1061
1062 if (shaderStorageBlockIndex >= shProg->NumShaderStorageBlocks) {
1063 _mesa_error(ctx, GL_INVALID_VALUE,
1064 "glShaderStorageBlockBinding(block index %u >= %u)",
1065 shaderStorageBlockIndex, shProg->NumShaderStorageBlocks);
1066 return;
1067 }
1068
1069 if (shaderStorageBlockBinding >= ctx->Const.MaxShaderStorageBufferBindings) {
1070 _mesa_error(ctx, GL_INVALID_VALUE,
1071 "glShaderStorageBlockBinding(block binding %u >= %u)",
1072 shaderStorageBlockBinding,
1073 ctx->Const.MaxShaderStorageBufferBindings);
1074 return;
1075 }
1076
1077 if (shProg->ShaderStorageBlocks[shaderStorageBlockIndex]->Binding !=
1078 shaderStorageBlockBinding) {
1079 int i;
1080
1081 FLUSH_VERTICES(ctx, 0);
1082 ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer;
1083
1084 const int interface_block_index =
1085 shProg->SsboInterfaceBlockIndex[shaderStorageBlockIndex];
1086
1087 shProg->BufferInterfaceBlocks[interface_block_index].Binding =
1088 shaderStorageBlockBinding;
1089
1090 for (i = 0; i < MESA_SHADER_STAGES; i++) {
1091 int stage_index =
1092 shProg->InterfaceBlockStageIndex[i][interface_block_index];
1093
1094 if (stage_index != -1) {
1095 struct gl_shader *sh = shProg->_LinkedShaders[i];
1096 sh->BufferInterfaceBlocks[stage_index].Binding = shaderStorageBlockBinding;
1097 }
1098 }
1099 }
1100 }
1101
1102 /**
1103 * Generic program resource property query.
1104 */
1105 static void
1106 mesa_bufferiv(struct gl_shader_program *shProg, GLenum type,
1107 GLuint index, GLenum pname, GLint *params, const char *caller)
1108 {
1109 GET_CURRENT_CONTEXT(ctx);
1110 struct gl_program_resource *res =
1111 _mesa_program_resource_find_index(shProg, type, index);
1112
1113 if (!res) {
1114 _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index);
1115 return;
1116 }
1117
1118 switch (pname) {
1119 case GL_UNIFORM_BLOCK_BINDING:
1120 case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1121 _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING,
1122 params, caller);
1123 return;
1124 case GL_UNIFORM_BLOCK_DATA_SIZE:
1125 case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
1126 _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE,
1127 params, caller);
1128 return;
1129 case GL_UNIFORM_BLOCK_NAME_LENGTH:
1130 _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH,
1131 params, caller);
1132 return;
1133 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
1134 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
1135 _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES,
1136 params, caller);
1137 return;
1138 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
1139 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
1140 _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES,
1141 params, caller);
1142 return;
1143 case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
1144 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
1145 _mesa_program_resource_prop(shProg, res, index,
1146 GL_REFERENCED_BY_VERTEX_SHADER, params,
1147 caller);
1148 return;
1149
1150 case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER:
1151 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
1152 _mesa_program_resource_prop(shProg, res, index,
1153 GL_REFERENCED_BY_TESS_CONTROL_SHADER, params,
1154 caller);
1155 return;
1156
1157 case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER:
1158 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
1159 _mesa_program_resource_prop(shProg, res, index,
1160 GL_REFERENCED_BY_TESS_EVALUATION_SHADER, params,
1161 caller);
1162 return;
1163
1164 case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
1165 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
1166 _mesa_program_resource_prop(shProg, res, index,
1167 GL_REFERENCED_BY_GEOMETRY_SHADER, params,
1168 caller);
1169 return;
1170 case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
1171 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
1172 _mesa_program_resource_prop(shProg, res, index,
1173 GL_REFERENCED_BY_FRAGMENT_SHADER, params,
1174 caller);
1175 return;
1176 default:
1177 _mesa_error(ctx, GL_INVALID_ENUM,
1178 "%s(pname 0x%x (%s))", caller, pname,
1179 _mesa_enum_to_string(pname));
1180 return;
1181 }
1182 }
1183
1184
1185 void GLAPIENTRY
1186 _mesa_GetActiveUniformBlockiv(GLuint program,
1187 GLuint uniformBlockIndex,
1188 GLenum pname,
1189 GLint *params)
1190 {
1191 GET_CURRENT_CONTEXT(ctx);
1192 struct gl_shader_program *shProg;
1193
1194 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1195 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1196 return;
1197 }
1198
1199 shProg = _mesa_lookup_shader_program_err(ctx, program,
1200 "glGetActiveUniformBlockiv");
1201 if (!shProg)
1202 return;
1203
1204 mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params,
1205 "glGetActiveUniformBlockiv");
1206 }
1207
1208 void GLAPIENTRY
1209 _mesa_GetActiveUniformBlockName(GLuint program,
1210 GLuint uniformBlockIndex,
1211 GLsizei bufSize,
1212 GLsizei *length,
1213 GLchar *uniformBlockName)
1214 {
1215 GET_CURRENT_CONTEXT(ctx);
1216 struct gl_shader_program *shProg;
1217
1218 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1219 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1220 return;
1221 }
1222
1223 if (bufSize < 0) {
1224 _mesa_error(ctx, GL_INVALID_VALUE,
1225 "glGetActiveUniformBlockName(bufSize %d < 0)",
1226 bufSize);
1227 return;
1228 }
1229
1230 shProg = _mesa_lookup_shader_program_err(ctx, program,
1231 "glGetActiveUniformBlockiv");
1232 if (!shProg)
1233 return;
1234
1235 if (uniformBlockName)
1236 _mesa_get_program_resource_name(shProg, GL_UNIFORM_BLOCK,
1237 uniformBlockIndex, bufSize, length,
1238 uniformBlockName,
1239 "glGetActiveUniformBlockName");
1240 }
1241
1242 void GLAPIENTRY
1243 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex,
1244 GLsizei bufSize, GLsizei *length,
1245 GLchar *uniformName)
1246 {
1247 GET_CURRENT_CONTEXT(ctx);
1248 struct gl_shader_program *shProg;
1249
1250 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1251 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName");
1252 return;
1253 }
1254
1255 if (bufSize < 0) {
1256 _mesa_error(ctx, GL_INVALID_VALUE,
1257 "glGetActiveUniformName(bufSize %d < 0)",
1258 bufSize);
1259 return;
1260 }
1261
1262 shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName");
1263
1264 if (!shProg)
1265 return;
1266
1267 _mesa_get_program_resource_name(shProg, GL_UNIFORM, uniformIndex, bufSize,
1268 length, uniformName, "glGetActiveUniformName");
1269 }
1270
1271 void GLAPIENTRY
1272 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex,
1273 GLenum pname, GLint *params)
1274 {
1275 GET_CURRENT_CONTEXT(ctx);
1276 struct gl_shader_program *shProg;
1277
1278 if (!ctx->Extensions.ARB_shader_atomic_counters) {
1279 _mesa_error(ctx, GL_INVALID_OPERATION,
1280 "glGetActiveAtomicCounterBufferiv");
1281 return;
1282 }
1283
1284 shProg = _mesa_lookup_shader_program_err(ctx, program,
1285 "glGetActiveAtomicCounterBufferiv");
1286 if (!shProg)
1287 return;
1288
1289 mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params,
1290 "glGetActiveAtomicCounterBufferiv");
1291 }
1292
1293 void GLAPIENTRY
1294 _mesa_Uniform1d(GLint location, GLdouble v0)
1295 {
1296 GET_CURRENT_CONTEXT(ctx);
1297 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1298 }
1299
1300 void GLAPIENTRY
1301 _mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1)
1302 {
1303 GET_CURRENT_CONTEXT(ctx);
1304 GLdouble v[2];
1305 v[0] = v0;
1306 v[1] = v1;
1307 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1308 }
1309
1310 void GLAPIENTRY
1311 _mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
1312 {
1313 GET_CURRENT_CONTEXT(ctx);
1314 GLdouble v[3];
1315 v[0] = v0;
1316 v[1] = v1;
1317 v[2] = v2;
1318 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1319 }
1320
1321 void GLAPIENTRY
1322 _mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2,
1323 GLdouble v3)
1324 {
1325 GET_CURRENT_CONTEXT(ctx);
1326 GLdouble v[4];
1327 v[0] = v0;
1328 v[1] = v1;
1329 v[2] = v2;
1330 v[3] = v3;
1331 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1332 }
1333
1334 void GLAPIENTRY
1335 _mesa_Uniform1dv(GLint location, GLsizei count, const GLdouble * value)
1336 {
1337 GET_CURRENT_CONTEXT(ctx);
1338 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 1);
1339 }
1340
1341 void GLAPIENTRY
1342 _mesa_Uniform2dv(GLint location, GLsizei count, const GLdouble * value)
1343 {
1344 GET_CURRENT_CONTEXT(ctx);
1345 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 2);
1346 }
1347
1348 void GLAPIENTRY
1349 _mesa_Uniform3dv(GLint location, GLsizei count, const GLdouble * value)
1350 {
1351 GET_CURRENT_CONTEXT(ctx);
1352 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 3);
1353 }
1354
1355 void GLAPIENTRY
1356 _mesa_Uniform4dv(GLint location, GLsizei count, const GLdouble * value)
1357 {
1358 GET_CURRENT_CONTEXT(ctx);
1359 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 4);
1360 }
1361
1362 void GLAPIENTRY
1363 _mesa_UniformMatrix2dv(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 2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1369 }
1370
1371 void GLAPIENTRY
1372 _mesa_UniformMatrix3dv(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 3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1378 }
1379
1380 void GLAPIENTRY
1381 _mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
1382 const GLdouble * value)
1383 {
1384 GET_CURRENT_CONTEXT(ctx);
1385 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1386 4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1387 }
1388
1389 void GLAPIENTRY
1390 _mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
1391 const GLdouble *value)
1392 {
1393 GET_CURRENT_CONTEXT(ctx);
1394 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1395 2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1396 }
1397
1398 void GLAPIENTRY
1399 _mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
1400 const GLdouble *value)
1401 {
1402 GET_CURRENT_CONTEXT(ctx);
1403 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1404 3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1405 }
1406
1407 void GLAPIENTRY
1408 _mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
1409 const GLdouble *value)
1410 {
1411 GET_CURRENT_CONTEXT(ctx);
1412 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1413 2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1414 }
1415
1416 void GLAPIENTRY
1417 _mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
1418 const GLdouble *value)
1419 {
1420 GET_CURRENT_CONTEXT(ctx);
1421 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1422 4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1423 }
1424
1425 void GLAPIENTRY
1426 _mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
1427 const GLdouble *value)
1428 {
1429 GET_CURRENT_CONTEXT(ctx);
1430 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1431 3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1432 }
1433
1434 void GLAPIENTRY
1435 _mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
1436 const GLdouble *value)
1437 {
1438 GET_CURRENT_CONTEXT(ctx);
1439 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1440 4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1441 }
1442
1443 void GLAPIENTRY
1444 _mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0)
1445 {
1446 GET_CURRENT_CONTEXT(ctx);
1447 struct gl_shader_program *shProg =
1448 _mesa_lookup_shader_program_err(ctx, program,
1449 "glProgramUniform1d");
1450 _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1451 }
1452
1453 void GLAPIENTRY
1454 _mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
1455 {
1456 GET_CURRENT_CONTEXT(ctx);
1457 GLdouble v[2];
1458 struct gl_shader_program *shProg;
1459 v[0] = v0;
1460 v[1] = v1;
1461 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d");
1462 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1463 }
1464
1465 void GLAPIENTRY
1466 _mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1467 GLdouble v2)
1468 {
1469 GET_CURRENT_CONTEXT(ctx);
1470 GLdouble v[3];
1471 struct gl_shader_program *shProg;
1472 v[0] = v0;
1473 v[1] = v1;
1474 v[2] = v2;
1475 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d");
1476 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1477 }
1478
1479 void GLAPIENTRY
1480 _mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1481 GLdouble v2, GLdouble v3)
1482 {
1483 GET_CURRENT_CONTEXT(ctx);
1484 GLdouble v[4];
1485 struct gl_shader_program *shProg;
1486 v[0] = v0;
1487 v[1] = v1;
1488 v[2] = v2;
1489 v[3] = v3;
1490 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d");
1491 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1492 }
1493
1494 void GLAPIENTRY
1495 _mesa_ProgramUniform1dv(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 "glProgramUniform1dv");
1502 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 1);
1503 }
1504
1505 void GLAPIENTRY
1506 _mesa_ProgramUniform2dv(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 "glProgramUniform2dv");
1513 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 2);
1514 }
1515
1516 void GLAPIENTRY
1517 _mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count,
1518 const GLdouble * value)
1519 {
1520 GET_CURRENT_CONTEXT(ctx);
1521 struct gl_shader_program *shProg =
1522 _mesa_lookup_shader_program_err(ctx, program,
1523 "glProgramUniform3dv");
1524 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 3);
1525 }
1526
1527 void GLAPIENTRY
1528 _mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count,
1529 const GLdouble * value)
1530 {
1531 GET_CURRENT_CONTEXT(ctx);
1532 struct gl_shader_program *shProg =
1533 _mesa_lookup_shader_program_err(ctx, program,
1534 "glProgramUniform4dv");
1535 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 4);
1536 }
1537
1538 void GLAPIENTRY
1539 _mesa_ProgramUniformMatrix2dv(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 "glProgramUniformMatrix2dv");
1546 _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1547 }
1548
1549 void GLAPIENTRY
1550 _mesa_ProgramUniformMatrix3dv(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 "glProgramUniformMatrix3dv");
1557 _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1558 }
1559
1560 void GLAPIENTRY
1561 _mesa_ProgramUniformMatrix4dv(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 "glProgramUniformMatrix4dv");
1568 _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1569 }
1570
1571 void GLAPIENTRY
1572 _mesa_ProgramUniformMatrix2x3dv(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 "glProgramUniformMatrix2x3dv");
1579 _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1580 }
1581
1582 void GLAPIENTRY
1583 _mesa_ProgramUniformMatrix3x2dv(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 "glProgramUniformMatrix3x2dv");
1590 _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1591 }
1592
1593 void GLAPIENTRY
1594 _mesa_ProgramUniformMatrix2x4dv(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 "glProgramUniformMatrix2x4dv");
1601 _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1602 }
1603
1604 void GLAPIENTRY
1605 _mesa_ProgramUniformMatrix4x2dv(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 "glProgramUniformMatrix4x2dv");
1612 _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1613 }
1614
1615 void GLAPIENTRY
1616 _mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count,
1617 GLboolean transpose, const GLdouble * value)
1618 {
1619 GET_CURRENT_CONTEXT(ctx);
1620 struct gl_shader_program *shProg =
1621 _mesa_lookup_shader_program_err(ctx, program,
1622 "glProgramUniformMatrix3x4dv");
1623 _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1624 }
1625
1626 void GLAPIENTRY
1627 _mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count,
1628 GLboolean transpose, const GLdouble * value)
1629 {
1630 GET_CURRENT_CONTEXT(ctx);
1631 struct gl_shader_program *shProg =
1632 _mesa_lookup_shader_program_err(ctx, program,
1633 "glProgramUniformMatrix4x3dv");
1634 _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GLSL_TYPE_DOUBLE);
1635 }