projects / mesa.git / blob
? search:


dc9b5a02b5c450781e7d66a36484f7df08083e92
[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, GL_FLOAT);
557 }
558
559 void GLAPIENTRY
560 _mesa_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
561 const GLfloat * value)
562 {
563 GET_CURRENT_CONTEXT(ctx);
564 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
565 3, 3, location, count, transpose, value, GL_FLOAT);
566 }
567
568 void GLAPIENTRY
569 _mesa_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
570 const GLfloat * value)
571 {
572 GET_CURRENT_CONTEXT(ctx);
573 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
574 4, 4, location, count, transpose, value, GL_FLOAT);
575 }
576
577 /** Same as above with direct state access **/
578
579 void GLAPIENTRY
580 _mesa_ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
581 {
582 GET_CURRENT_CONTEXT(ctx);
583 struct gl_shader_program *shProg =
584 _mesa_lookup_shader_program_err(ctx, program,
585 "glProgramUniform1ui");
586 _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_UINT, 1);
587 }
588
589 void GLAPIENTRY
590 _mesa_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
591 {
592 GET_CURRENT_CONTEXT(ctx);
593 GLuint v[2];
594 struct gl_shader_program *shProg;
595 v[0] = v0;
596 v[1] = v1;
597 shProg = _mesa_lookup_shader_program_err(ctx, program,
598 "glProgramUniform2ui");
599 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 2);
600 }
601
602 void GLAPIENTRY
603 _mesa_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1,
604 GLuint v2)
605 {
606 GET_CURRENT_CONTEXT(ctx);
607 GLuint v[3];
608 struct gl_shader_program *shProg;
609 v[0] = v0;
610 v[1] = v1;
611 v[2] = v2;
612 shProg = _mesa_lookup_shader_program_err(ctx, program,
613 "glProgramUniform3ui");
614 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 3);
615 }
616
617 void GLAPIENTRY
618 _mesa_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1,
619 GLuint v2, GLuint v3)
620 {
621 GET_CURRENT_CONTEXT(ctx);
622 GLuint v[4];
623 struct gl_shader_program *shProg;
624 v[0] = v0;
625 v[1] = v1;
626 v[2] = v2;
627 v[3] = v3;
628 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4ui");
629 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_UINT, 4);
630 }
631
632 void GLAPIENTRY
633 _mesa_ProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
634 const GLuint *value)
635 {
636 GET_CURRENT_CONTEXT(ctx);
637 struct gl_shader_program *shProg =
638 _mesa_lookup_shader_program_err(ctx, program,
639 "glProgramUniform1uiv");
640 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 1);
641 }
642
643 void GLAPIENTRY
644 _mesa_ProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
645 const GLuint *value)
646 {
647 GET_CURRENT_CONTEXT(ctx);
648 struct gl_shader_program *shProg =
649 _mesa_lookup_shader_program_err(ctx, program,
650 "glProgramUniform2uiv");
651 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 2);
652 }
653
654 void GLAPIENTRY
655 _mesa_ProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
656 const GLuint *value)
657 {
658 GET_CURRENT_CONTEXT(ctx);
659 struct gl_shader_program *shProg =
660 _mesa_lookup_shader_program_err(ctx, program,
661 "glProgramUniform3uiv");
662 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 3);
663 }
664
665 void GLAPIENTRY
666 _mesa_ProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
667 const GLuint *value)
668 {
669 GET_CURRENT_CONTEXT(ctx);
670 struct gl_shader_program *shProg =
671 _mesa_lookup_shader_program_err(ctx, program,
672 "glProgramUniform4uiv");
673 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_UINT, 4);
674 }
675
676
677
678 void GLAPIENTRY
679 _mesa_ProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count,
680 GLboolean transpose, const GLfloat * value)
681 {
682 GET_CURRENT_CONTEXT(ctx);
683 struct gl_shader_program *shProg =
684 _mesa_lookup_shader_program_err(ctx, program,
685 "glProgramUniformMatrix2fv");
686 _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GL_FLOAT);
687 }
688
689 void GLAPIENTRY
690 _mesa_ProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count,
691 GLboolean transpose, const GLfloat * value)
692 {
693 GET_CURRENT_CONTEXT(ctx);
694 struct gl_shader_program *shProg =
695 _mesa_lookup_shader_program_err(ctx, program,
696 "glProgramUniformMatrix3fv");
697 _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GL_FLOAT);
698 }
699
700 void GLAPIENTRY
701 _mesa_ProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count,
702 GLboolean transpose, const GLfloat * value)
703 {
704 GET_CURRENT_CONTEXT(ctx);
705 struct gl_shader_program *shProg =
706 _mesa_lookup_shader_program_err(ctx, program,
707 "glProgramUniformMatrix4fv");
708 _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GL_FLOAT);
709 }
710
711
712 /**
713 * Non-square UniformMatrix are OpenGL 2.1
714 */
715 void GLAPIENTRY
716 _mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
717 const GLfloat *value)
718 {
719 GET_CURRENT_CONTEXT(ctx);
720 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
721 2, 3, location, count, transpose, value, GL_FLOAT);
722 }
723
724 void GLAPIENTRY
725 _mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
726 const GLfloat *value)
727 {
728 GET_CURRENT_CONTEXT(ctx);
729 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
730 3, 2, location, count, transpose, value, GL_FLOAT);
731 }
732
733 void GLAPIENTRY
734 _mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
735 const GLfloat *value)
736 {
737 GET_CURRENT_CONTEXT(ctx);
738 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
739 2, 4, location, count, transpose, value, GL_FLOAT);
740 }
741
742 void GLAPIENTRY
743 _mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
744 const GLfloat *value)
745 {
746 GET_CURRENT_CONTEXT(ctx);
747 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
748 4, 2, location, count, transpose, value, GL_FLOAT);
749 }
750
751 void GLAPIENTRY
752 _mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
753 const GLfloat *value)
754 {
755 GET_CURRENT_CONTEXT(ctx);
756 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
757 3, 4, location, count, transpose, value, GL_FLOAT);
758 }
759
760 void GLAPIENTRY
761 _mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
762 const GLfloat *value)
763 {
764 GET_CURRENT_CONTEXT(ctx);
765 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
766 4, 3, location, count, transpose, value, GL_FLOAT);
767 }
768
769 /** Same as above with direct state access **/
770
771 void GLAPIENTRY
772 _mesa_ProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count,
773 GLboolean transpose, const GLfloat * value)
774 {
775 GET_CURRENT_CONTEXT(ctx);
776 struct gl_shader_program *shProg =
777 _mesa_lookup_shader_program_err(ctx, program,
778 "glProgramUniformMatrix2x3fv");
779 _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GL_FLOAT);
780 }
781
782 void GLAPIENTRY
783 _mesa_ProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count,
784 GLboolean transpose, const GLfloat * value)
785 {
786 GET_CURRENT_CONTEXT(ctx);
787 struct gl_shader_program *shProg =
788 _mesa_lookup_shader_program_err(ctx, program,
789 "glProgramUniformMatrix3x2fv");
790 _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GL_FLOAT);
791 }
792
793 void GLAPIENTRY
794 _mesa_ProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count,
795 GLboolean transpose, const GLfloat * value)
796 {
797 GET_CURRENT_CONTEXT(ctx);
798 struct gl_shader_program *shProg =
799 _mesa_lookup_shader_program_err(ctx, program,
800 "glProgramUniformMatrix2x4fv");
801 _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GL_FLOAT);
802 }
803
804 void GLAPIENTRY
805 _mesa_ProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count,
806 GLboolean transpose, const GLfloat * value)
807 {
808 GET_CURRENT_CONTEXT(ctx);
809 struct gl_shader_program *shProg =
810 _mesa_lookup_shader_program_err(ctx, program,
811 "glProgramUniformMatrix4x2fv");
812 _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GL_FLOAT);
813 }
814
815 void GLAPIENTRY
816 _mesa_ProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count,
817 GLboolean transpose, const GLfloat * value)
818 {
819 GET_CURRENT_CONTEXT(ctx);
820 struct gl_shader_program *shProg =
821 _mesa_lookup_shader_program_err(ctx, program,
822 "glProgramUniformMatrix3x4fv");
823 _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GL_FLOAT);
824 }
825
826 void GLAPIENTRY
827 _mesa_ProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count,
828 GLboolean transpose, const GLfloat * value)
829 {
830 GET_CURRENT_CONTEXT(ctx);
831 struct gl_shader_program *shProg =
832 _mesa_lookup_shader_program_err(ctx, program,
833 "glProgramUniformMatrix4x3fv");
834 _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GL_FLOAT);
835 }
836
837
838 void GLAPIENTRY
839 _mesa_GetnUniformfvARB(GLuint program, GLint location,
840 GLsizei bufSize, GLfloat *params)
841 {
842 GET_CURRENT_CONTEXT(ctx);
843 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_FLOAT, params);
844 }
845
846 void GLAPIENTRY
847 _mesa_GetUniformfv(GLuint program, GLint location, GLfloat *params)
848 {
849 _mesa_GetnUniformfvARB(program, location, INT_MAX, params);
850 }
851
852
853 void GLAPIENTRY
854 _mesa_GetnUniformivARB(GLuint program, GLint location,
855 GLsizei bufSize, GLint *params)
856 {
857 GET_CURRENT_CONTEXT(ctx);
858 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT, params);
859 }
860
861 void GLAPIENTRY
862 _mesa_GetUniformiv(GLuint program, GLint location, GLint *params)
863 {
864 _mesa_GetnUniformivARB(program, location, INT_MAX, params);
865 }
866
867
868 /* GL3 */
869 void GLAPIENTRY
870 _mesa_GetnUniformuivARB(GLuint program, GLint location,
871 GLsizei bufSize, GLuint *params)
872 {
873 GET_CURRENT_CONTEXT(ctx);
874 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT, params);
875 }
876
877 void GLAPIENTRY
878 _mesa_GetUniformuiv(GLuint program, GLint location, GLuint *params)
879 {
880 _mesa_GetnUniformuivARB(program, location, INT_MAX, params);
881 }
882
883
884 /* GL4 */
885 void GLAPIENTRY
886 _mesa_GetnUniformdvARB(GLuint program, GLint location,
887 GLsizei bufSize, GLdouble *params)
888 {
889 GET_CURRENT_CONTEXT(ctx);
890
891 (void) program;
892 (void) location;
893 (void) bufSize;
894 (void) params;
895
896 /*
897 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_DOUBLE, params);
898 */
899 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformdvARB"
900 "(GL_ARB_gpu_shader_fp64 not implemented)");
901 }
902
903 void GLAPIENTRY
904 _mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params)
905 {
906 _mesa_GetnUniformdvARB(program, location, INT_MAX, params);
907 }
908
909
910 GLint GLAPIENTRY
911 _mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name)
912 {
913 struct gl_shader_program *shProg;
914 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
1065 /**
1066 * Generic program resource property query.
1067 */
1068 static void
1069 mesa_bufferiv(struct gl_shader_program *shProg, GLenum type,
1070 GLuint index, GLenum pname, GLint *params, const char *caller)
1071 {
1072 GET_CURRENT_CONTEXT(ctx);
1073 struct gl_program_resource *res =
1074 _mesa_program_resource_find_index(shProg, type, index);
1075
1076 if (!res) {
1077 _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index);
1078 return;
1079 }
1080
1081 switch (pname) {
1082 case GL_UNIFORM_BLOCK_BINDING:
1083 case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1084 _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING,
1085 params, caller);
1086 return;
1087 case GL_UNIFORM_BLOCK_DATA_SIZE:
1088 case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
1089 _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE,
1090 params, caller);
1091 return;
1092 case GL_UNIFORM_BLOCK_NAME_LENGTH:
1093 _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH,
1094 params, caller);
1095 return;
1096 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
1097 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
1098 _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES,
1099 params, caller);
1100 return;
1101 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
1102 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
1103 _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES,
1104 params, caller);
1105 return;
1106 case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
1107 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
1108 _mesa_program_resource_prop(shProg, res, index,
1109 GL_REFERENCED_BY_VERTEX_SHADER, params,
1110 caller);
1111 return;
1112 case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
1113 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
1114 _mesa_program_resource_prop(shProg, res, index,
1115 GL_REFERENCED_BY_GEOMETRY_SHADER, params,
1116 caller);
1117 return;
1118 case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
1119 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
1120 _mesa_program_resource_prop(shProg, res, index,
1121 GL_REFERENCED_BY_FRAGMENT_SHADER, params,
1122 caller);
1123 return;
1124 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
1125 params[0] = GL_FALSE;
1126 return;
1127 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
1128 params[0] = GL_FALSE;
1129 return;
1130 default:
1131 _mesa_error(ctx, GL_INVALID_ENUM,
1132 "%s(pname 0x%x (%s))", caller, pname,
1133 _mesa_lookup_enum_by_nr(pname));
1134 return;
1135 }
1136 }
1137
1138
1139 void GLAPIENTRY
1140 _mesa_GetActiveUniformBlockiv(GLuint program,
1141 GLuint uniformBlockIndex,
1142 GLenum pname,
1143 GLint *params)
1144 {
1145 GET_CURRENT_CONTEXT(ctx);
1146 struct gl_shader_program *shProg;
1147
1148 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1149 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1150 return;
1151 }
1152
1153 shProg = _mesa_lookup_shader_program_err(ctx, program,
1154 "glGetActiveUniformBlockiv");
1155 if (!shProg)
1156 return;
1157
1158 mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params,
1159 "glGetActiveUniformBlockiv");
1160 }
1161
1162 void GLAPIENTRY
1163 _mesa_GetActiveUniformBlockName(GLuint program,
1164 GLuint uniformBlockIndex,
1165 GLsizei bufSize,
1166 GLsizei *length,
1167 GLchar *uniformBlockName)
1168 {
1169 GET_CURRENT_CONTEXT(ctx);
1170 struct gl_shader_program *shProg;
1171 struct gl_uniform_block *block;
1172
1173 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1174 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv");
1175 return;
1176 }
1177
1178 if (bufSize < 0) {
1179 _mesa_error(ctx, GL_INVALID_VALUE,
1180 "glGetActiveUniformBlockName(bufSize %d < 0)",
1181 bufSize);
1182 return;
1183 }
1184
1185 shProg = _mesa_lookup_shader_program_err(ctx, program,
1186 "glGetActiveUniformBlockiv");
1187 if (!shProg)
1188 return;
1189
1190 if (uniformBlockIndex >= shProg->NumUniformBlocks) {
1191 _mesa_error(ctx, GL_INVALID_VALUE,
1192 "glGetActiveUniformBlockiv(block index %u >= %u)",
1193 uniformBlockIndex, shProg->NumUniformBlocks);
1194 return;
1195 }
1196
1197 block = &shProg->UniformBlocks[uniformBlockIndex];
1198
1199 if (uniformBlockName) {
1200 _mesa_copy_string(uniformBlockName, bufSize, length, block->Name);
1201 }
1202 }
1203
1204 void GLAPIENTRY
1205 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex,
1206 GLsizei bufSize, GLsizei *length,
1207 GLchar *uniformName)
1208 {
1209 GET_CURRENT_CONTEXT(ctx);
1210 struct gl_shader_program *shProg;
1211
1212 if (!ctx->Extensions.ARB_uniform_buffer_object) {
1213 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName");
1214 return;
1215 }
1216
1217 if (bufSize < 0) {
1218 _mesa_error(ctx, GL_INVALID_VALUE,
1219 "glGetActiveUniformName(bufSize %d < 0)",
1220 bufSize);
1221 return;
1222 }
1223
1224 shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName");
1225
1226 if (!shProg)
1227 return;
1228
1229 if (uniformIndex >= shProg->NumUserUniformStorage) {
1230 _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
1231 return;
1232 }
1233
1234 if (uniformName) {
1235 _mesa_get_uniform_name(& shProg->UniformStorage[uniformIndex],
1236 bufSize, length, uniformName);
1237 }
1238 }
1239
1240 void
1241 _mesa_get_uniform_name(const struct gl_uniform_storage *uni,
1242 GLsizei maxLength, GLsizei *length,
1243 GLchar *nameOut)
1244 {
1245 GLsizei localLength;
1246
1247 if (length == NULL)
1248 length = &localLength;
1249
1250 _mesa_copy_string(nameOut, maxLength, length, uni->name);
1251
1252 /* Page 61 (page 73 of the PDF) in section 2.11 of the OpenGL ES 3.0
1253 * spec says:
1254 *
1255 * "If the active uniform is an array, the uniform name returned in
1256 * name will always be the name of the uniform array appended with
1257 * "[0]"."
1258 *
1259 * The same text also appears in the OpenGL 4.2 spec. It does not,
1260 * however, appear in any previous spec. Previous specifications are
1261 * ambiguous in this regard. However, either name can later be passed
1262 * to glGetUniformLocation (and related APIs), so there shouldn't be any
1263 * harm in always appending "[0]" to uniform array names.
1264 */
1265 if (uni->array_elements != 0) {
1266 int i;
1267
1268 /* The comparison is strange because *length does *NOT* include the
1269 * terminating NUL, but maxLength does.
1270 */
1271 for (i = 0; i < 3 && (*length + i + 1) < maxLength; i++)
1272 nameOut[*length + i] = "[0]"[i];
1273
1274 nameOut[*length + i] = '\0';
1275 *length += i;
1276 }
1277 }
1278
1279 void GLAPIENTRY
1280 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex,
1281 GLenum pname, GLint *params)
1282 {
1283 GET_CURRENT_CONTEXT(ctx);
1284 struct gl_shader_program *shProg;
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 mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params,
1298 "glGetActiveAtomicCounterBufferiv");
1299 }
1300
1301 void GLAPIENTRY
1302 _mesa_Uniform1d(GLint location, GLdouble v0)
1303 {
1304 GET_CURRENT_CONTEXT(ctx);
1305 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1306 }
1307
1308 void GLAPIENTRY
1309 _mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1)
1310 {
1311 GET_CURRENT_CONTEXT(ctx);
1312 GLdouble v[2];
1313 v[0] = v0;
1314 v[1] = v1;
1315 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1316 }
1317
1318 void GLAPIENTRY
1319 _mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
1320 {
1321 GET_CURRENT_CONTEXT(ctx);
1322 GLdouble v[3];
1323 v[0] = v0;
1324 v[1] = v1;
1325 v[2] = v2;
1326 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1327 }
1328
1329 void GLAPIENTRY
1330 _mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2,
1331 GLdouble v3)
1332 {
1333 GET_CURRENT_CONTEXT(ctx);
1334 GLdouble v[4];
1335 v[0] = v0;
1336 v[1] = v1;
1337 v[2] = v2;
1338 v[3] = v3;
1339 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1340 }
1341
1342 void GLAPIENTRY
1343 _mesa_Uniform1dv(GLint location, GLsizei count, const GLdouble * value)
1344 {
1345 GET_CURRENT_CONTEXT(ctx);
1346 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 1);
1347 }
1348
1349 void GLAPIENTRY
1350 _mesa_Uniform2dv(GLint location, GLsizei count, const GLdouble * value)
1351 {
1352 GET_CURRENT_CONTEXT(ctx);
1353 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 2);
1354 }
1355
1356 void GLAPIENTRY
1357 _mesa_Uniform3dv(GLint location, GLsizei count, const GLdouble * value)
1358 {
1359 GET_CURRENT_CONTEXT(ctx);
1360 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 3);
1361 }
1362
1363 void GLAPIENTRY
1364 _mesa_Uniform4dv(GLint location, GLsizei count, const GLdouble * value)
1365 {
1366 GET_CURRENT_CONTEXT(ctx);
1367 _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GLSL_TYPE_DOUBLE, 4);
1368 }
1369
1370 void GLAPIENTRY
1371 _mesa_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,
1372 const GLdouble * value)
1373 {
1374 GET_CURRENT_CONTEXT(ctx);
1375 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1376 2, 2, location, count, transpose, value, GL_DOUBLE);
1377 }
1378
1379 void GLAPIENTRY
1380 _mesa_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,
1381 const GLdouble * value)
1382 {
1383 GET_CURRENT_CONTEXT(ctx);
1384 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1385 3, 3, location, count, transpose, value, GL_DOUBLE);
1386 }
1387
1388 void GLAPIENTRY
1389 _mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
1390 const GLdouble * value)
1391 {
1392 GET_CURRENT_CONTEXT(ctx);
1393 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1394 4, 4, location, count, transpose, value, GL_DOUBLE);
1395 }
1396
1397 void GLAPIENTRY
1398 _mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
1399 const GLdouble *value)
1400 {
1401 GET_CURRENT_CONTEXT(ctx);
1402 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1403 2, 3, location, count, transpose, value, GL_DOUBLE);
1404 }
1405
1406 void GLAPIENTRY
1407 _mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
1408 const GLdouble *value)
1409 {
1410 GET_CURRENT_CONTEXT(ctx);
1411 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1412 3, 2, location, count, transpose, value, GL_DOUBLE);
1413 }
1414
1415 void GLAPIENTRY
1416 _mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
1417 const GLdouble *value)
1418 {
1419 GET_CURRENT_CONTEXT(ctx);
1420 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1421 2, 4, location, count, transpose, value, GL_DOUBLE);
1422 }
1423
1424 void GLAPIENTRY
1425 _mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
1426 const GLdouble *value)
1427 {
1428 GET_CURRENT_CONTEXT(ctx);
1429 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1430 4, 2, location, count, transpose, value, GL_DOUBLE);
1431 }
1432
1433 void GLAPIENTRY
1434 _mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
1435 const GLdouble *value)
1436 {
1437 GET_CURRENT_CONTEXT(ctx);
1438 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1439 3, 4, location, count, transpose, value, GL_DOUBLE);
1440 }
1441
1442 void GLAPIENTRY
1443 _mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
1444 const GLdouble *value)
1445 {
1446 GET_CURRENT_CONTEXT(ctx);
1447 _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
1448 4, 3, location, count, transpose, value, GL_DOUBLE);
1449 }
1450
1451 void GLAPIENTRY
1452 _mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0)
1453 {
1454 GET_CURRENT_CONTEXT(ctx);
1455 struct gl_shader_program *shProg =
1456 _mesa_lookup_shader_program_err(ctx, program,
1457 "glProgramUniform1d");
1458 _mesa_uniform(ctx, shProg, location, 1, &v0, GLSL_TYPE_DOUBLE, 1);
1459 }
1460
1461 void GLAPIENTRY
1462 _mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
1463 {
1464 GET_CURRENT_CONTEXT(ctx);
1465 GLdouble v[2];
1466 struct gl_shader_program *shProg;
1467 v[0] = v0;
1468 v[1] = v1;
1469 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d");
1470 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 2);
1471 }
1472
1473 void GLAPIENTRY
1474 _mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1475 GLdouble v2)
1476 {
1477 GET_CURRENT_CONTEXT(ctx);
1478 GLdouble v[3];
1479 struct gl_shader_program *shProg;
1480 v[0] = v0;
1481 v[1] = v1;
1482 v[2] = v2;
1483 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d");
1484 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 3);
1485 }
1486
1487 void GLAPIENTRY
1488 _mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1,
1489 GLdouble v2, GLdouble v3)
1490 {
1491 GET_CURRENT_CONTEXT(ctx);
1492 GLdouble v[4];
1493 struct gl_shader_program *shProg;
1494 v[0] = v0;
1495 v[1] = v1;
1496 v[2] = v2;
1497 v[3] = v3;
1498 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d");
1499 _mesa_uniform(ctx, shProg, location, 1, v, GLSL_TYPE_DOUBLE, 4);
1500 }
1501
1502 void GLAPIENTRY
1503 _mesa_ProgramUniform1dv(GLuint program, GLint location, GLsizei count,
1504 const GLdouble * value)
1505 {
1506 GET_CURRENT_CONTEXT(ctx);
1507 struct gl_shader_program *shProg =
1508 _mesa_lookup_shader_program_err(ctx, program,
1509 "glProgramUniform1dv");
1510 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 1);
1511 }
1512
1513 void GLAPIENTRY
1514 _mesa_ProgramUniform2dv(GLuint program, GLint location, GLsizei count,
1515 const GLdouble * value)
1516 {
1517 GET_CURRENT_CONTEXT(ctx);
1518 struct gl_shader_program *shProg =
1519 _mesa_lookup_shader_program_err(ctx, program,
1520 "glProgramUniform2dv");
1521 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 2);
1522 }
1523
1524 void GLAPIENTRY
1525 _mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count,
1526 const GLdouble * value)
1527 {
1528 GET_CURRENT_CONTEXT(ctx);
1529 struct gl_shader_program *shProg =
1530 _mesa_lookup_shader_program_err(ctx, program,
1531 "glProgramUniform3dv");
1532 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 3);
1533 }
1534
1535 void GLAPIENTRY
1536 _mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count,
1537 const GLdouble * value)
1538 {
1539 GET_CURRENT_CONTEXT(ctx);
1540 struct gl_shader_program *shProg =
1541 _mesa_lookup_shader_program_err(ctx, program,
1542 "glProgramUniform4dv");
1543 _mesa_uniform(ctx, shProg, location, count, value, GLSL_TYPE_DOUBLE, 4);
1544 }
1545
1546 void GLAPIENTRY
1547 _mesa_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count,
1548 GLboolean transpose, const GLdouble * value)
1549 {
1550 GET_CURRENT_CONTEXT(ctx);
1551 struct gl_shader_program *shProg =
1552 _mesa_lookup_shader_program_err(ctx, program,
1553 "glProgramUniformMatrix2dv");
1554 _mesa_uniform_matrix(ctx, shProg, 2, 2, location, count, transpose, value, GL_DOUBLE);
1555 }
1556
1557 void GLAPIENTRY
1558 _mesa_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count,
1559 GLboolean transpose, const GLdouble * value)
1560 {
1561 GET_CURRENT_CONTEXT(ctx);
1562 struct gl_shader_program *shProg =
1563 _mesa_lookup_shader_program_err(ctx, program,
1564 "glProgramUniformMatrix3dv");
1565 _mesa_uniform_matrix(ctx, shProg, 3, 3, location, count, transpose, value, GL_DOUBLE);
1566 }
1567
1568 void GLAPIENTRY
1569 _mesa_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count,
1570 GLboolean transpose, const GLdouble * value)
1571 {
1572 GET_CURRENT_CONTEXT(ctx);
1573 struct gl_shader_program *shProg =
1574 _mesa_lookup_shader_program_err(ctx, program,
1575 "glProgramUniformMatrix4dv");
1576 _mesa_uniform_matrix(ctx, shProg, 4, 4, location, count, transpose, value, GL_DOUBLE);
1577 }
1578
1579 void GLAPIENTRY
1580 _mesa_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count,
1581 GLboolean transpose, const GLdouble * value)
1582 {
1583 GET_CURRENT_CONTEXT(ctx);
1584 struct gl_shader_program *shProg =
1585 _mesa_lookup_shader_program_err(ctx, program,
1586 "glProgramUniformMatrix2x3dv");
1587 _mesa_uniform_matrix(ctx, shProg, 2, 3, location, count, transpose, value, GL_DOUBLE);
1588 }
1589
1590 void GLAPIENTRY
1591 _mesa_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count,
1592 GLboolean transpose, const GLdouble * value)
1593 {
1594 GET_CURRENT_CONTEXT(ctx);
1595 struct gl_shader_program *shProg =
1596 _mesa_lookup_shader_program_err(ctx, program,
1597 "glProgramUniformMatrix3x2dv");
1598 _mesa_uniform_matrix(ctx, shProg, 3, 2, location, count, transpose, value, GL_DOUBLE);
1599 }
1600
1601 void GLAPIENTRY
1602 _mesa_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count,
1603 GLboolean transpose, const GLdouble * value)
1604 {
1605 GET_CURRENT_CONTEXT(ctx);
1606 struct gl_shader_program *shProg =
1607 _mesa_lookup_shader_program_err(ctx, program,
1608 "glProgramUniformMatrix2x4dv");
1609 _mesa_uniform_matrix(ctx, shProg, 2, 4, location, count, transpose, value, GL_DOUBLE);
1610 }
1611
1612 void GLAPIENTRY
1613 _mesa_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count,
1614 GLboolean transpose, const GLdouble * value)
1615 {
1616 GET_CURRENT_CONTEXT(ctx);
1617 struct gl_shader_program *shProg =
1618 _mesa_lookup_shader_program_err(ctx, program,
1619 "glProgramUniformMatrix4x2dv");
1620 _mesa_uniform_matrix(ctx, shProg, 4, 2, location, count, transpose, value, GL_DOUBLE);
1621 }
1622
1623 void GLAPIENTRY
1624 _mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count,
1625 GLboolean transpose, const GLdouble * value)
1626 {
1627 GET_CURRENT_CONTEXT(ctx);
1628 struct gl_shader_program *shProg =
1629 _mesa_lookup_shader_program_err(ctx, program,
1630 "glProgramUniformMatrix3x4dv");
1631 _mesa_uniform_matrix(ctx, shProg, 3, 4, location, count, transpose, value, GL_DOUBLE);
1632 }
1633
1634 void GLAPIENTRY
1635 _mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count,
1636 GLboolean transpose, const GLdouble * value)
1637 {
1638 GET_CURRENT_CONTEXT(ctx);
1639 struct gl_shader_program *shProg =
1640 _mesa_lookup_shader_program_err(ctx, program,
1641 "glProgramUniformMatrix4x3dv");
1642 _mesa_uniform_matrix(ctx, shProg, 4, 3, location, count, transpose, value, GL_DOUBLE);
1643 }