projects / mesa.git / blob
? search:


c30710772c7b48c2c9fb182eff2c75998c6281ea
[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 < Elements(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, GL_FLOAT);
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, GL_FLOAT_VEC2);
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, GL_FLOAT_VEC3);
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, GL_FLOAT_VEC4);
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, GL_INT);
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, GL_INT_VEC2);
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, GL_INT_VEC3);
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, GL_INT_VEC4);
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, GL_FLOAT);
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, GL_FLOAT_VEC2);
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, GL_FLOAT_VEC3);
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, GL_FLOAT_VEC4);
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, GL_INT);
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, GL_INT_VEC2);
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, GL_INT_VEC3);
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, GL_INT_VEC4);
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, GL_FLOAT);
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, GL_FLOAT_VEC2);
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, GL_FLOAT_VEC3);
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, GL_FLOAT_VEC4);
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, GL_INT);
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, GL_INT_VEC2);
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, GL_INT_VEC3);
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, GL_INT_VEC4);
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, GL_FLOAT);
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, GL_FLOAT_VEC2);
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, GL_FLOAT_VEC3);
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, GL_FLOAT_VEC4);
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, GL_INT);
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, GL_INT_VEC2);
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, GL_INT_VEC3);
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, GL_INT_VEC4);
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, GL_UNSIGNED_INT);
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, GL_UNSIGNED_INT_VEC2);
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, GL_UNSIGNED_INT_VEC3);
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, GL_UNSIGNED_INT_VEC4);
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, GL_UNSIGNED_INT);
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, GL_UNSIGNED_INT_VEC2);
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, GL_UNSIGNED_INT_VEC3);
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, GL_UNSIGNED_INT_VEC4);
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);
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);
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);
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, GL_UNSIGNED_INT);
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, GL_UNSIGNED_INT_VEC2);
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, GL_UNSIGNED_INT_VEC3);
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, GL_UNSIGNED_INT_VEC4);
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, GL_UNSIGNED_INT);
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, GL_UNSIGNED_INT_VEC2);
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, GL_UNSIGNED_INT_VEC3);
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, GL_UNSIGNED_INT_VEC4);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
835 }
836
837
838 void GLAPIENTRY
839 _mesa_GetnUniformfvARB(GLuint program, GLint location,
840 GLsizei bufSize, GLfloat *params)
841 {
842 GET_CURRENT_CONTEXT(ctx);
843 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_FLOAT, params);
844 }
845
846 void GLAPIENTRY
847 _mesa_GetUniformfv(GLuint program, GLint location, GLfloat *params)
848 {
849 _mesa_GetnUniformfvARB(program, location, INT_MAX, params);
850 }
851
852
853 void GLAPIENTRY
854 _mesa_GetnUniformivARB(GLuint program, GLint location,
855 GLsizei bufSize, GLint *params)
856 {
857 GET_CURRENT_CONTEXT(ctx);
858 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT, params);
859 }
860
861 void GLAPIENTRY
862 _mesa_GetUniformiv(GLuint program, GLint location, GLint *params)
863 {
864 _mesa_GetnUniformivARB(program, location, INT_MAX, params);
865 }
866
867
868 /* GL3 */
869 void GLAPIENTRY
870 _mesa_GetnUniformuivARB(GLuint program, GLint location,
871 GLsizei bufSize, GLuint *params)
872 {
873 GET_CURRENT_CONTEXT(ctx);
874 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT, params);
875 }
876
877 void GLAPIENTRY
878 _mesa_GetUniformuiv(GLuint program, GLint location, GLuint *params)
879 {
880 _mesa_GetnUniformuivARB(program, location, INT_MAX, params);
881 }
882
883
884 /* GL4 */
885 void GLAPIENTRY
886 _mesa_GetnUniformdvARB(GLuint program, GLint location,
887 GLsizei bufSize, GLdouble *params)
888 {
889 GET_CURRENT_CONTEXT(ctx);
890
891 (void) program;
892 (void) location;
893 (void) bufSize;
894 (void) params;
895
896 /*
897 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_DOUBLE, params);
898 */
899 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformdvARB"
900 "(GL_ARB_gpu_shader_fp64 not implemented)");
901 }
902
903 void GLAPIENTRY
904 _mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params)
905 {
906 _mesa_GetnUniformdvARB(program, location, INT_MAX, params);
907 }
908
909
910 GLint GLAPIENTRY
911 _mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name)
912 {
913 struct gl_shader_program *shProg;
914 GLuint index, offset;
915
916 GET_CURRENT_CONTEXT(ctx);
917
918 shProg = _mesa_lookup_shader_program_err(ctx, programObj,
919 "glGetUniformLocation");
920 if (!shProg)
921 return -1;
922
923 /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says:
924 *
925 * "If program has not been successfully linked, the error
926 * INVALID_OPERATION is generated."
927 */
928 if (shProg->LinkStatus == GL_FALSE) {
929 _mesa_error(ctx, GL_INVALID_OPERATION,
930 "glGetUniformLocation(program not linked)");
931 return -1;
932 }
933
934 index = _mesa_get_uniform_location(shProg, name, &offset);
935 if (index == GL_INVALID_INDEX)
936 return -1;
937
938 /* From the GL_ARB_uniform_buffer_object spec:
939 *
940 * "The value -1 will be returned if <name> does not correspond to an
941 * active uniform variable name in <program>, if <name> is associated
942 * with a named uniform block, or if <name> starts with the reserved
943 * prefix "gl_"."
944 */
945 if (shProg->UniformStorage[index].block_index != -1 ||
946 shProg->UniformStorage[index].atomic_buffer_index != -1)
947 return -1;
948
949 /* location in remap table + array element offset */
950 return shProg->UniformStorage[index].remap_location + offset;
951 }
952
953 GLuint GLAPIENTRY
954 _mesa_GetUniformBlockIndex(GLuint program,
955 const GLchar *uniformBlockName)
956 {
957 GET_CURRENT_CONTEXT(ctx);
958 GLuint i;
959 struct gl_shader_program *shProg;
960
961 if (!ctx->Extensions.ARB_uniform_buffer_object) {
962 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex");
963 return GL_INVALID_INDEX;
964 }
965
966 shProg = _mesa_lookup_shader_program_err(ctx, program,
967 "glGetUniformBlockIndex");
968 if (!shProg)
969 return GL_INVALID_INDEX;
970
971 for (i = 0; i < shProg->NumUniformBlocks; i++) {
972 if (!strcmp(shProg->UniformBlocks[i].Name, uniformBlockName))
973 return i;
974 }
975
976 return GL_INVALID_INDEX;
977 }
978
979 void GLAPIENTRY
980 _mesa_GetUniformIndices(GLuint program,
981 GLsizei uniformCount,
982 const GLchar * const *uniformNames,
983 GLuint *uniformIndices)
984 {
985 GET_CURRENT_CONTEXT(ctx);
986 GLsizei i;
987 struct gl_shader_program *shProg;
988
989 if (!ctx->Extensions.ARB_uniform_buffer_object) {
990 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices");
991 return;
992 }
993
994 shProg = _mesa_lookup_shader_program_err(ctx, program,
995 "glGetUniformIndices");
996 if (!shProg)
997 return;
998
999 if (uniformCount < 0) {
1000 _mesa_error(ctx, GL_INVALID_VALUE,
1001 "glGetUniformIndices(uniformCount < 0)");
1002 return;
1003 }
1004
1005 for (i = 0; i < uniformCount; i++) {
1006 unsigned offset;
1007 uniformIndices[i] = _mesa_get_uniform_location(shProg,
1008 uniformNames[i], &offset);
1009 }
1010 }
1011
1012 void GLAPIENTRY
1013 _mesa_UniformBlockBinding(GLuint program,
1014 GLuint uniformBlockIndex,
1015 GLuint uniformBlockBinding)
1016 {
1017 GET_CURRENT_CONTEXT(ctx);
1018 struct gl_shader_program *shProg;
1019
1020 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1021 _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding");
1022 return;
1023 }
1024
1025 shProg = _mesa_lookup_shader_program_err(ctx, program,
1026 "glUniformBlockBinding");
1027 if (!shProg)
1028 return;
1029
1030 if (uniformBlockIndex >= shProg->NumUniformBlocks) {
1031 _mesa_error(ctx, GL_INVALID_VALUE,
1032 "glUniformBlockBinding(block index %u >= %u)",
1033 uniformBlockIndex, shProg->NumUniformBlocks);
1034 return;
1035 }
1036
1037 if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) {
1038 _mesa_error(ctx, GL_INVALID_VALUE,
1039 "glUniformBlockBinding(block binding %u >= %u)",
1040 uniformBlockBinding, ctx->Const.MaxUniformBufferBindings);
1041 return;
1042 }
1043
1044 if (shProg->UniformBlocks[uniformBlockIndex].Binding !=
1045 uniformBlockBinding) {
1046 int i;
1047
1048 FLUSH_VERTICES(ctx, 0);
1049 ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
1050
1051 shProg->UniformBlocks[uniformBlockIndex].Binding = uniformBlockBinding;
1052
1053 for (i = 0; i < MESA_SHADER_STAGES; i++) {
1054 int stage_index = shProg->UniformBlockStageIndex[i][uniformBlockIndex];
1055
1056 if (stage_index != -1) {
1057 struct gl_shader *sh = shProg->_LinkedShaders[i];
1058 sh->UniformBlocks[stage_index].Binding = uniformBlockBinding;
1059 }
1060 }
1061 }
1062 }
1063
1064 void GLAPIENTRY
1065 _mesa_GetActiveUniformBlockiv(GLuint program,
1066 GLuint uniformBlockIndex,
1067 GLenum pname,
1068 GLint *params)
1069 {
1070 GET_CURRENT_CONTEXT(ctx);
1071 struct gl_shader_program *shProg;
1072 struct gl_uniform_block *block;
1073 unsigned i;
1074
1075 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1076 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1077 return;
1078 }
1079
1080 shProg = _mesa_lookup_shader_program_err(ctx, program,
1081 "glGetActiveUniformBlockiv");
1082 if (!shProg)
1083 return;
1084
1085 if (uniformBlockIndex >= shProg->NumUniformBlocks) {
1086 _mesa_error(ctx, GL_INVALID_VALUE,
1087 "glGetActiveUniformBlockiv(block index %u >= %u)",
1088 uniformBlockIndex, shProg->NumUniformBlocks);
1089 return;
1090 }
1091
1092 block = &shProg->UniformBlocks[uniformBlockIndex];
1093
1094 switch (pname) {
1095 case GL_UNIFORM_BLOCK_BINDING:
1096 params[0] = block->Binding;
1097 return;
1098
1099 case GL_UNIFORM_BLOCK_DATA_SIZE:
1100 params[0] = block->UniformBufferSize;
1101 return;
1102
1103 case GL_UNIFORM_BLOCK_NAME_LENGTH:
1104 params[0] = strlen(block->Name) + 1;
1105 return;
1106
1107 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS: {
1108 unsigned count = 0;
1109
1110 for (i = 0; i < block->NumUniforms; i++) {
1111 unsigned offset;
1112 const int idx =
1113 _mesa_get_uniform_location(shProg,
1114 block->Uniforms[i].IndexName,
1115 &offset);
1116 if (idx != -1)
1117 count++;
1118 }
1119
1120 params[0] = count;
1121 return;
1122 }
1123
1124 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: {
1125 unsigned count = 0;
1126
1127 for (i = 0; i < block->NumUniforms; i++) {
1128 unsigned offset;
1129 const int idx =
1130 _mesa_get_uniform_location(shProg,
1131 block->Uniforms[i].IndexName,
1132 &offset);
1133
1134 if (idx != -1)
1135 params[count++] = idx;
1136 }
1137 return;
1138 }
1139
1140 case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
1141 params[0] = shProg->UniformBlockStageIndex[MESA_SHADER_VERTEX][uniformBlockIndex] != -1;
1142 return;
1143
1144 case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
1145 params[0] = shProg->UniformBlockStageIndex[MESA_SHADER_GEOMETRY][uniformBlockIndex] != -1;
1146 return;
1147
1148 case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
1149 params[0] = shProg->UniformBlockStageIndex[MESA_SHADER_FRAGMENT][uniformBlockIndex] != -1;
1150 return;
1151
1152 default:
1153 _mesa_error(ctx, GL_INVALID_ENUM,
1154 "glGetActiveUniformBlockiv(pname 0x%x (%s))",
1155 pname, _mesa_lookup_enum_by_nr(pname));
1156 return;
1157 }
1158 }
1159
1160 void GLAPIENTRY
1161 _mesa_GetActiveUniformBlockName(GLuint program,
1162 GLuint uniformBlockIndex,
1163 GLsizei bufSize,
1164 GLsizei *length,
1165 GLchar *uniformBlockName)
1166 {
1167 GET_CURRENT_CONTEXT(ctx);
1168 struct gl_shader_program *shProg;
1169 struct gl_uniform_block *block;
1170
1171 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1172 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1173 return;
1174 }
1175
1176 if (bufSize < 0) {
1177 _mesa_error(ctx, GL_INVALID_VALUE,
1178 "glGetActiveUniformBlockName(bufSize %d < 0)",
1179 bufSize);
1180 return;
1181 }
1182
1183 shProg = _mesa_lookup_shader_program_err(ctx, program,
1184 "glGetActiveUniformBlockiv");
1185 if (!shProg)
1186 return;
1187
1188 if (uniformBlockIndex >= shProg->NumUniformBlocks) {
1189 _mesa_error(ctx, GL_INVALID_VALUE,
1190 "glGetActiveUniformBlockiv(block index %u >= %u)",
1191 uniformBlockIndex, shProg->NumUniformBlocks);
1192 return;
1193 }
1194
1195 block = &shProg->UniformBlocks[uniformBlockIndex];
1196
1197 if (uniformBlockName) {
1198 _mesa_copy_string(uniformBlockName, bufSize, length, block->Name);
1199 }
1200 }
1201
1202 void GLAPIENTRY
1203 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex,
1204 GLsizei bufSize, GLsizei *length,
1205 GLchar *uniformName)
1206 {
1207 GET_CURRENT_CONTEXT(ctx);
1208 struct gl_shader_program *shProg;
1209
1210 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1211 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1212 return;
1213 }
1214
1215 if (bufSize < 0) {
1216 _mesa_error(ctx, GL_INVALID_VALUE,
1217 "glGetActiveUniformName(bufSize %d < 0)",
1218 bufSize);
1219 return;
1220 }
1221
1222 shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName");
1223
1224 if (!shProg)
1225 return;
1226
1227 if (uniformIndex >= shProg->NumUserUniformStorage) {
1228 _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
1229 return;
1230 }
1231
1232 if (uniformName) {
1233 _mesa_get_uniform_name(& shProg->UniformStorage[uniformIndex],
1234 bufSize, length, uniformName);
1235 }
1236 }
1237
1238 void
1239 _mesa_get_uniform_name(const struct gl_uniform_storage *uni,
1240 GLsizei maxLength, GLsizei *length,
1241 GLchar *nameOut)
1242 {
1243 GLsizei localLength;
1244
1245 if (length == NULL)
1246 length = &localLength;
1247
1248 _mesa_copy_string(nameOut, maxLength, length, uni->name);
1249
1250 /* Page 61 (page 73 of the PDF) in section 2.11 of the OpenGL ES 3.0
1251 * spec says:
1252 *
1253 * "If the active uniform is an array, the uniform name returned in
1254 * name will always be the name of the uniform array appended with
1255 * "[0]"."
1256 *
1257 * The same text also appears in the OpenGL 4.2 spec. It does not,
1258 * however, appear in any previous spec. Previous specifications are
1259 * ambiguous in this regard. However, either name can later be passed
1260 * to glGetUniformLocation (and related APIs), so there shouldn't be any
1261 * harm in always appending "[0]" to uniform array names.
1262 */
1263 if (uni->array_elements != 0) {
1264 int i;
1265
1266 /* The comparison is strange because *length does *NOT* include the
1267 * terminating NUL, but maxLength does.
1268 */
1269 for (i = 0; i < 3 && (*length + i + 1) < maxLength; i++)
1270 nameOut[*length + i] = "[0]"[i];
1271
1272 nameOut[*length + i] = '\0';
1273 *length += i;
1274 }
1275 }
1276
1277 void GLAPIENTRY
1278 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex,
1279 GLenum pname, GLint *params)
1280 {
1281 GET_CURRENT_CONTEXT(ctx);
1282 struct gl_shader_program *shProg;
1283 struct gl_active_atomic_buffer *ab;
1284 GLuint i;
1285
1286 if (!ctx->Extensions.ARB_shader_atomic_counters) {
1287 _mesa_error(ctx, GL_INVALID_OPERATION,
1288 "glGetActiveAtomicCounterBufferiv");
1289 return;
1290 }
1291
1292 shProg = _mesa_lookup_shader_program_err(ctx, program,
1293 "glGetActiveAtomicCounterBufferiv");
1294 if (!shProg)
1295 return;
1296
1297 if (bufferIndex >= shProg->NumAtomicBuffers) {
1298 _mesa_error(ctx, GL_INVALID_VALUE,
1299 "glGetActiveAtomicCounterBufferiv(bufferIndex)");
1300 return;
1301 }
1302
1303 ab = &shProg->AtomicBuffers[bufferIndex];
1304
1305 switch (pname) {
1306 case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1307 params[0] = ab->Binding;
1308 return;
1309 case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
1310 params[0] = ab->MinimumSize;
1311 return;
1312 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
1313 params[0] = ab->NumUniforms;
1314 return;
1315 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
1316 for (i = 0; i < ab->NumUniforms; ++i)
1317 params[i] = ab->Uniforms[i];
1318 return;
1319 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
1320 params[0] = ab->StageReferences[MESA_SHADER_VERTEX];
1321 return;
1322 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
1323 params[0] = ab->StageReferences[MESA_SHADER_GEOMETRY];
1324 return;
1325 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
1326 params[0] = ab->StageReferences[MESA_SHADER_FRAGMENT];
1327 return;
1328 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
1329 params[0] = GL_FALSE;
1330 return;
1331 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
1332 params[0] = GL_FALSE;
1333 return;
1334 default:
1335 _mesa_error(ctx, GL_INVALID_ENUM,
1336 "glGetActiveAtomicCounterBufferiv(pname 0x%x (%s))",
1337 pname, _mesa_lookup_enum_by_nr(pname));
1338 return;
1339 }
1340 }