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