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