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 static inline void 67 update_single_shader_texture_used(struct gl_shader_program *shProg, 68 struct gl_program *prog, 69 GLuint unit, GLuint target) 70 { 71 gl_shader_stage prog_stage = 72 _mesa_program_enum_to_shader_stage(prog->Target); 73 74 assert(unit < ARRAY_SIZE(prog->TexturesUsed)); 75 assert(target < NUM_TEXTURE_TARGETS); 76 77 /* From section 7.10 (Samplers) of the OpenGL 4.5 spec: 78 * 79 * "It is not allowed to have variables of different sampler types pointing 80 * to the same texture image unit within a program object." 81 */ 82 unsigned stages_mask = shProg->data->linked_stages; 83 while (stages_mask) { 84 const int stage = u_bit_scan(&stages_mask); 85 86 /* Skip validation if we are yet to update textures used in this 87 * stage. 88 */ 89 if (prog_stage < stage) 90 break; 91 92 struct gl_program *glprog = shProg->_LinkedShaders[stage]->Program; 93 if (glprog->TexturesUsed[unit] & ~(1 << target)) 94 shProg->SamplersValidated = GL_FALSE; 95 } 96 97 prog->TexturesUsed[unit] |= (1 << target); 98 } 99 100 void 101 _mesa_update_shader_textures_used(struct gl_shader_program *shProg, 102 struct gl_program *prog) 103 { 104 GLbitfield mask = prog->SamplersUsed; 105 gl_shader_stage prog_stage = 106 _mesa_program_enum_to_shader_stage(prog->Target); 107 MAYBE_UNUSED struct gl_linked_shader *shader = 108 shProg->_LinkedShaders[prog_stage]; 109 GLuint s; 110 111 assert(shader); 112 113 memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed)); 114 115 while (mask) { 116 s = u_bit_scan(&mask); 117 118 update_single_shader_texture_used(shProg, prog, 119 prog->SamplerUnits[s], 120 prog->sh.SamplerTargets[s]); 121 } 122 123 if (unlikely(prog->sh.HasBoundBindlessSampler)) { 124 /* Loop over bindless samplers bound to texture units. 125 */ 126 for (s = 0; s < prog->sh.NumBindlessSamplers; s++) { 127 struct gl_bindless_sampler *sampler = &prog->sh.BindlessSamplers[s]; 128 129 if (!sampler->bound) 130 continue; 131 132 update_single_shader_texture_used(shProg, prog, sampler->unit, 133 sampler->target); 134 } 135 } 136 } 137 138 /** 139 * Connect a piece of driver storage with a part of a uniform 140 * 141 * \param uni The uniform with which the storage will be associated 142 * \param element_stride Byte-stride between array elements. 143 * \sa gl_uniform_driver_storage::element_stride. 144 * \param vector_stride Byte-stride between vectors (in a matrix). 145 * \sa gl_uniform_driver_storage::vector_stride. 146 * \param format Conversion from native format to driver format 147 * required by the driver. 148 * \param data Location to dump the data. 149 */ 150 void 151 _mesa_uniform_attach_driver_storage(struct gl_uniform_storage *uni, 152 unsigned element_stride, 153 unsigned vector_stride, 154 enum gl_uniform_driver_format format, 155 void *data) 156 { 157 uni->driver_storage = 158 realloc(uni->driver_storage, 159 sizeof(struct gl_uniform_driver_storage) 160 * (uni->num_driver_storage + 1)); 161 162 uni->driver_storage[uni->num_driver_storage].element_stride = element_stride; 163 uni->driver_storage[uni->num_driver_storage].vector_stride = vector_stride; 164 uni->driver_storage[uni->num_driver_storage].format = format; 165 uni->driver_storage[uni->num_driver_storage].data = data; 166 167 uni->num_driver_storage++; 168 } 169 170 /** 171 * Sever all connections with all pieces of driver storage for all uniforms 172 * 173 * \warning 174 * This function does \b not release any of the \c data pointers 175 * previously passed in to \c _mesa_uniform_attach_driver_stoarge. 176 */ 177 void 178 _mesa_uniform_detach_all_driver_storage(struct gl_uniform_storage *uni) 179 { 180 free(uni->driver_storage); 181 uni->driver_storage = NULL; 182 uni->num_driver_storage = 0; 183 } 184 185 void GLAPIENTRY 186 _mesa_Uniform1f(GLint location, GLfloat v0) 187 { 188 GET_CURRENT_CONTEXT(ctx); 189 _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 1); 190 } 191 192 void GLAPIENTRY 193 _mesa_Uniform2f(GLint location, GLfloat v0, GLfloat v1) 194 { 195 GET_CURRENT_CONTEXT(ctx); 196 GLfloat v[2]; 197 v[0] = v0; 198 v[1] = v1; 199 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 2); 200 } 201 202 void GLAPIENTRY 203 _mesa_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) 204 { 205 GET_CURRENT_CONTEXT(ctx); 206 GLfloat v[3]; 207 v[0] = v0; 208 v[1] = v1; 209 v[2] = v2; 210 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 3); 211 } 212 213 void GLAPIENTRY 214 _mesa_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, 215 GLfloat v3) 216 { 217 GET_CURRENT_CONTEXT(ctx); 218 GLfloat v[4]; 219 v[0] = v0; 220 v[1] = v1; 221 v[2] = v2; 222 v[3] = v3; 223 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 4); 224 } 225 226 void GLAPIENTRY 227 _mesa_Uniform1i(GLint location, GLint v0) 228 { 229 GET_CURRENT_CONTEXT(ctx); 230 _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 1); 231 } 232 233 void GLAPIENTRY 234 _mesa_Uniform2i(GLint location, GLint v0, GLint v1) 235 { 236 GET_CURRENT_CONTEXT(ctx); 237 GLint v[2]; 238 v[0] = v0; 239 v[1] = v1; 240 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 2); 241 } 242 243 void GLAPIENTRY 244 _mesa_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2) 245 { 246 GET_CURRENT_CONTEXT(ctx); 247 GLint v[3]; 248 v[0] = v0; 249 v[1] = v1; 250 v[2] = v2; 251 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 3); 252 } 253 254 void GLAPIENTRY 255 _mesa_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) 256 { 257 GET_CURRENT_CONTEXT(ctx); 258 GLint v[4]; 259 v[0] = v0; 260 v[1] = v1; 261 v[2] = v2; 262 v[3] = v3; 263 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 4); 264 } 265 266 void GLAPIENTRY 267 _mesa_Uniform1fv(GLint location, GLsizei count, const GLfloat * value) 268 { 269 GET_CURRENT_CONTEXT(ctx); 270 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 1); 271 } 272 273 void GLAPIENTRY 274 _mesa_Uniform2fv(GLint location, GLsizei count, const GLfloat * value) 275 { 276 GET_CURRENT_CONTEXT(ctx); 277 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 2); 278 } 279 280 void GLAPIENTRY 281 _mesa_Uniform3fv(GLint location, GLsizei count, const GLfloat * value) 282 { 283 GET_CURRENT_CONTEXT(ctx); 284 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 3); 285 } 286 287 void GLAPIENTRY 288 _mesa_Uniform4fv(GLint location, GLsizei count, const GLfloat * value) 289 { 290 GET_CURRENT_CONTEXT(ctx); 291 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_FLOAT, 4); 292 } 293 294 void GLAPIENTRY 295 _mesa_Uniform1iv(GLint location, GLsizei count, const GLint * value) 296 { 297 GET_CURRENT_CONTEXT(ctx); 298 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 1); 299 } 300 301 void GLAPIENTRY 302 _mesa_Uniform2iv(GLint location, GLsizei count, const GLint * value) 303 { 304 GET_CURRENT_CONTEXT(ctx); 305 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 2); 306 } 307 308 void GLAPIENTRY 309 _mesa_Uniform3iv(GLint location, GLsizei count, const GLint * value) 310 { 311 GET_CURRENT_CONTEXT(ctx); 312 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 3); 313 } 314 315 void GLAPIENTRY 316 _mesa_Uniform4iv(GLint location, GLsizei count, const GLint * value) 317 { 318 GET_CURRENT_CONTEXT(ctx); 319 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT, 4); 320 } 321 322 void GLAPIENTRY 323 _mesa_UniformHandleui64ARB(GLint location, GLuint64 value) 324 { 325 GET_CURRENT_CONTEXT(ctx); 326 _mesa_uniform_handle(location, 1, &value, ctx, ctx->_Shader->ActiveProgram); 327 } 328 329 void GLAPIENTRY 330 _mesa_UniformHandleui64vARB(GLint location, GLsizei count, 331 const GLuint64 *value) 332 { 333 GET_CURRENT_CONTEXT(ctx); 334 _mesa_uniform_handle(location, count, value, ctx, 335 ctx->_Shader->ActiveProgram); 336 } 337 338 339 /** Same as above with direct state access **/ 340 void GLAPIENTRY 341 _mesa_ProgramUniform1f(GLuint program, GLint location, GLfloat v0) 342 { 343 GET_CURRENT_CONTEXT(ctx); 344 struct gl_shader_program *shProg = 345 _mesa_lookup_shader_program_err(ctx, program, 346 "glProgramUniform1f"); 347 _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_FLOAT, 1); 348 } 349 350 void GLAPIENTRY 351 _mesa_ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1) 352 { 353 GET_CURRENT_CONTEXT(ctx); 354 GLfloat v[2]; 355 struct gl_shader_program *shProg; 356 v[0] = v0; 357 v[1] = v1; 358 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2f"); 359 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_FLOAT, 2); 360 } 361 362 void GLAPIENTRY 363 _mesa_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, 364 GLfloat v2) 365 { 366 GET_CURRENT_CONTEXT(ctx); 367 GLfloat v[3]; 368 struct gl_shader_program *shProg; 369 v[0] = v0; 370 v[1] = v1; 371 v[2] = v2; 372 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3f"); 373 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_FLOAT, 3); 374 } 375 376 void GLAPIENTRY 377 _mesa_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, 378 GLfloat v2, GLfloat v3) 379 { 380 GET_CURRENT_CONTEXT(ctx); 381 GLfloat v[4]; 382 struct gl_shader_program *shProg; 383 v[0] = v0; 384 v[1] = v1; 385 v[2] = v2; 386 v[3] = v3; 387 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4f"); 388 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_FLOAT, 4); 389 } 390 391 void GLAPIENTRY 392 _mesa_ProgramUniform1i(GLuint program, GLint location, GLint v0) 393 { 394 GET_CURRENT_CONTEXT(ctx); 395 struct gl_shader_program *shProg = 396 _mesa_lookup_shader_program_err(ctx, program, 397 "glProgramUniform1i"); 398 _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_INT, 1); 399 } 400 401 void GLAPIENTRY 402 _mesa_ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1) 403 { 404 GET_CURRENT_CONTEXT(ctx); 405 GLint v[2]; 406 struct gl_shader_program *shProg; 407 v[0] = v0; 408 v[1] = v1; 409 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2i"); 410 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT, 2); 411 } 412 413 void GLAPIENTRY 414 _mesa_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, 415 GLint v2) 416 { 417 GET_CURRENT_CONTEXT(ctx); 418 GLint v[3]; 419 struct gl_shader_program *shProg; 420 v[0] = v0; 421 v[1] = v1; 422 v[2] = v2; 423 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3i"); 424 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT, 3); 425 } 426 427 void GLAPIENTRY 428 _mesa_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, 429 GLint v2, GLint v3) 430 { 431 GET_CURRENT_CONTEXT(ctx); 432 GLint v[4]; 433 struct gl_shader_program *shProg; 434 v[0] = v0; 435 v[1] = v1; 436 v[2] = v2; 437 v[3] = v3; 438 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4i"); 439 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT, 4); 440 } 441 442 void GLAPIENTRY 443 _mesa_ProgramUniform1fv(GLuint program, GLint location, GLsizei count, 444 const GLfloat * value) 445 { 446 GET_CURRENT_CONTEXT(ctx); 447 struct gl_shader_program *shProg = 448 _mesa_lookup_shader_program_err(ctx, program, 449 "glProgramUniform1fv"); 450 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 1); 451 } 452 453 void GLAPIENTRY 454 _mesa_ProgramUniform2fv(GLuint program, GLint location, GLsizei count, 455 const GLfloat * value) 456 { 457 GET_CURRENT_CONTEXT(ctx); 458 struct gl_shader_program *shProg = 459 _mesa_lookup_shader_program_err(ctx, program, 460 "glProgramUniform2fv"); 461 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 2); 462 } 463 464 void GLAPIENTRY 465 _mesa_ProgramUniform3fv(GLuint program, GLint location, GLsizei count, 466 const GLfloat * value) 467 { 468 GET_CURRENT_CONTEXT(ctx); 469 struct gl_shader_program *shProg = 470 _mesa_lookup_shader_program_err(ctx, program, 471 "glProgramUniform3fv"); 472 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 3); 473 } 474 475 void GLAPIENTRY 476 _mesa_ProgramUniform4fv(GLuint program, GLint location, GLsizei count, 477 const GLfloat * value) 478 { 479 GET_CURRENT_CONTEXT(ctx); 480 struct gl_shader_program *shProg = 481 _mesa_lookup_shader_program_err(ctx, program, 482 "glProgramUniform4fv"); 483 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_FLOAT, 4); 484 } 485 486 void GLAPIENTRY 487 _mesa_ProgramUniform1iv(GLuint program, GLint location, GLsizei count, 488 const GLint * value) 489 { 490 GET_CURRENT_CONTEXT(ctx); 491 struct gl_shader_program *shProg = 492 _mesa_lookup_shader_program_err(ctx, program, 493 "glProgramUniform1iv"); 494 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 1); 495 } 496 497 void GLAPIENTRY 498 _mesa_ProgramUniform2iv(GLuint program, GLint location, GLsizei count, 499 const GLint * value) 500 { 501 GET_CURRENT_CONTEXT(ctx); 502 struct gl_shader_program *shProg = 503 _mesa_lookup_shader_program_err(ctx, program, 504 "glProgramUniform2iv"); 505 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 2); 506 } 507 508 void GLAPIENTRY 509 _mesa_ProgramUniform3iv(GLuint program, GLint location, GLsizei count, 510 const GLint * value) 511 { 512 GET_CURRENT_CONTEXT(ctx); 513 struct gl_shader_program *shProg = 514 _mesa_lookup_shader_program_err(ctx, program, 515 "glProgramUniform3iv"); 516 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 3); 517 } 518 519 void GLAPIENTRY 520 _mesa_ProgramUniform4iv(GLuint program, GLint location, GLsizei count, 521 const GLint * value) 522 { 523 GET_CURRENT_CONTEXT(ctx); 524 struct gl_shader_program *shProg = 525 _mesa_lookup_shader_program_err(ctx, program, 526 "glProgramUniform4iv"); 527 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT, 4); 528 } 529 530 void GLAPIENTRY 531 _mesa_ProgramUniformHandleui64ARB(GLuint program, GLint location, 532 GLuint64 value) 533 { 534 GET_CURRENT_CONTEXT(ctx); 535 struct gl_shader_program *shProg = 536 _mesa_lookup_shader_program_err(ctx, program, 537 "glProgramUniformHandleui64ARB"); 538 _mesa_uniform_handle(location, 1, &value, ctx, shProg); 539 } 540 541 void GLAPIENTRY 542 _mesa_ProgramUniformHandleui64vARB(GLuint program, GLint location, 543 GLsizei count, const GLuint64 *values) 544 { 545 GET_CURRENT_CONTEXT(ctx); 546 struct gl_shader_program *shProg = 547 _mesa_lookup_shader_program_err(ctx, program, 548 "glProgramUniformHandleui64vARB"); 549 _mesa_uniform_handle(location, count, values, ctx, shProg); 550 } 551 552 553 /** OpenGL 3.0 GLuint-valued functions **/ 554 void GLAPIENTRY 555 _mesa_Uniform1ui(GLint location, GLuint v0) 556 { 557 GET_CURRENT_CONTEXT(ctx); 558 _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 1); 559 } 560 561 void GLAPIENTRY 562 _mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1) 563 { 564 GET_CURRENT_CONTEXT(ctx); 565 GLuint v[2]; 566 v[0] = v0; 567 v[1] = v1; 568 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 2); 569 } 570 571 void GLAPIENTRY 572 _mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) 573 { 574 GET_CURRENT_CONTEXT(ctx); 575 GLuint v[3]; 576 v[0] = v0; 577 v[1] = v1; 578 v[2] = v2; 579 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 3); 580 } 581 582 void GLAPIENTRY 583 _mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) 584 { 585 GET_CURRENT_CONTEXT(ctx); 586 GLuint v[4]; 587 v[0] = v0; 588 v[1] = v1; 589 v[2] = v2; 590 v[3] = v3; 591 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 4); 592 } 593 594 void GLAPIENTRY 595 _mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value) 596 { 597 GET_CURRENT_CONTEXT(ctx); 598 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 1); 599 } 600 601 void GLAPIENTRY 602 _mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value) 603 { 604 GET_CURRENT_CONTEXT(ctx); 605 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 2); 606 } 607 608 void GLAPIENTRY 609 _mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value) 610 { 611 GET_CURRENT_CONTEXT(ctx); 612 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 3); 613 } 614 615 void GLAPIENTRY 616 _mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value) 617 { 618 GET_CURRENT_CONTEXT(ctx); 619 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT, 4); 620 } 621 622 623 624 void GLAPIENTRY 625 _mesa_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, 626 const GLfloat * value) 627 { 628 GET_CURRENT_CONTEXT(ctx); 629 _mesa_uniform_matrix(location, count, transpose, value, 630 ctx, ctx->_Shader->ActiveProgram, 2, 2, GLSL_TYPE_FLOAT); 631 } 632 633 void GLAPIENTRY 634 _mesa_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, 635 const GLfloat * value) 636 { 637 GET_CURRENT_CONTEXT(ctx); 638 _mesa_uniform_matrix(location, count, transpose, value, 639 ctx, ctx->_Shader->ActiveProgram, 3, 3, GLSL_TYPE_FLOAT); 640 } 641 642 void GLAPIENTRY 643 _mesa_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, 644 const GLfloat * value) 645 { 646 GET_CURRENT_CONTEXT(ctx); 647 _mesa_uniform_matrix(location, count, transpose, value, 648 ctx, ctx->_Shader->ActiveProgram, 4, 4, GLSL_TYPE_FLOAT); 649 } 650 651 /** Same as above with direct state access **/ 652 653 void GLAPIENTRY 654 _mesa_ProgramUniform1ui(GLuint program, GLint location, GLuint v0) 655 { 656 GET_CURRENT_CONTEXT(ctx); 657 struct gl_shader_program *shProg = 658 _mesa_lookup_shader_program_err(ctx, program, 659 "glProgramUniform1ui"); 660 _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_UINT, 1); 661 } 662 663 void GLAPIENTRY 664 _mesa_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1) 665 { 666 GET_CURRENT_CONTEXT(ctx); 667 GLuint v[2]; 668 struct gl_shader_program *shProg; 669 v[0] = v0; 670 v[1] = v1; 671 shProg = _mesa_lookup_shader_program_err(ctx, program, 672 "glProgramUniform2ui"); 673 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT, 2); 674 } 675 676 void GLAPIENTRY 677 _mesa_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, 678 GLuint v2) 679 { 680 GET_CURRENT_CONTEXT(ctx); 681 GLuint v[3]; 682 struct gl_shader_program *shProg; 683 v[0] = v0; 684 v[1] = v1; 685 v[2] = v2; 686 shProg = _mesa_lookup_shader_program_err(ctx, program, 687 "glProgramUniform3ui"); 688 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT, 3); 689 } 690 691 void GLAPIENTRY 692 _mesa_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, 693 GLuint v2, GLuint v3) 694 { 695 GET_CURRENT_CONTEXT(ctx); 696 GLuint v[4]; 697 struct gl_shader_program *shProg; 698 v[0] = v0; 699 v[1] = v1; 700 v[2] = v2; 701 v[3] = v3; 702 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4ui"); 703 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT, 4); 704 } 705 706 void GLAPIENTRY 707 _mesa_ProgramUniform1uiv(GLuint program, GLint location, GLsizei count, 708 const GLuint *value) 709 { 710 GET_CURRENT_CONTEXT(ctx); 711 struct gl_shader_program *shProg = 712 _mesa_lookup_shader_program_err(ctx, program, 713 "glProgramUniform1uiv"); 714 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 1); 715 } 716 717 void GLAPIENTRY 718 _mesa_ProgramUniform2uiv(GLuint program, GLint location, GLsizei count, 719 const GLuint *value) 720 { 721 GET_CURRENT_CONTEXT(ctx); 722 struct gl_shader_program *shProg = 723 _mesa_lookup_shader_program_err(ctx, program, 724 "glProgramUniform2uiv"); 725 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 2); 726 } 727 728 void GLAPIENTRY 729 _mesa_ProgramUniform3uiv(GLuint program, GLint location, GLsizei count, 730 const GLuint *value) 731 { 732 GET_CURRENT_CONTEXT(ctx); 733 struct gl_shader_program *shProg = 734 _mesa_lookup_shader_program_err(ctx, program, 735 "glProgramUniform3uiv"); 736 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 3); 737 } 738 739 void GLAPIENTRY 740 _mesa_ProgramUniform4uiv(GLuint program, GLint location, GLsizei count, 741 const GLuint *value) 742 { 743 GET_CURRENT_CONTEXT(ctx); 744 struct gl_shader_program *shProg = 745 _mesa_lookup_shader_program_err(ctx, program, 746 "glProgramUniform4uiv"); 747 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT, 4); 748 } 749 750 751 752 void GLAPIENTRY 753 _mesa_ProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, 754 GLboolean transpose, const GLfloat * value) 755 { 756 GET_CURRENT_CONTEXT(ctx); 757 struct gl_shader_program *shProg = 758 _mesa_lookup_shader_program_err(ctx, program, 759 "glProgramUniformMatrix2fv"); 760 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 2, 2, GLSL_TYPE_FLOAT); 761 } 762 763 void GLAPIENTRY 764 _mesa_ProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, 765 GLboolean transpose, const GLfloat * value) 766 { 767 GET_CURRENT_CONTEXT(ctx); 768 struct gl_shader_program *shProg = 769 _mesa_lookup_shader_program_err(ctx, program, 770 "glProgramUniformMatrix3fv"); 771 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 3, 3, GLSL_TYPE_FLOAT); 772 } 773 774 void GLAPIENTRY 775 _mesa_ProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, 776 GLboolean transpose, const GLfloat * value) 777 { 778 GET_CURRENT_CONTEXT(ctx); 779 struct gl_shader_program *shProg = 780 _mesa_lookup_shader_program_err(ctx, program, 781 "glProgramUniformMatrix4fv"); 782 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 4, 4, GLSL_TYPE_FLOAT); 783 } 784 785 786 /** 787 * Non-square UniformMatrix are OpenGL 2.1 788 */ 789 void GLAPIENTRY 790 _mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, 791 const GLfloat *value) 792 { 793 GET_CURRENT_CONTEXT(ctx); 794 _mesa_uniform_matrix(location, count, transpose, value, 795 ctx, ctx->_Shader->ActiveProgram, 2, 3, GLSL_TYPE_FLOAT); 796 } 797 798 void GLAPIENTRY 799 _mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, 800 const GLfloat *value) 801 { 802 GET_CURRENT_CONTEXT(ctx); 803 _mesa_uniform_matrix(location, count, transpose, value, 804 ctx, ctx->_Shader->ActiveProgram, 3, 2, GLSL_TYPE_FLOAT); 805 } 806 807 void GLAPIENTRY 808 _mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, 809 const GLfloat *value) 810 { 811 GET_CURRENT_CONTEXT(ctx); 812 _mesa_uniform_matrix(location, count, transpose, value, 813 ctx, ctx->_Shader->ActiveProgram, 2, 4, GLSL_TYPE_FLOAT); 814 } 815 816 void GLAPIENTRY 817 _mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, 818 const GLfloat *value) 819 { 820 GET_CURRENT_CONTEXT(ctx); 821 _mesa_uniform_matrix(location, count, transpose, value, 822 ctx, ctx->_Shader->ActiveProgram, 4, 2, GLSL_TYPE_FLOAT); 823 } 824 825 void GLAPIENTRY 826 _mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, 827 const GLfloat *value) 828 { 829 GET_CURRENT_CONTEXT(ctx); 830 _mesa_uniform_matrix(location, count, transpose, value, 831 ctx, ctx->_Shader->ActiveProgram, 3, 4, GLSL_TYPE_FLOAT); 832 } 833 834 void GLAPIENTRY 835 _mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, 836 const GLfloat *value) 837 { 838 GET_CURRENT_CONTEXT(ctx); 839 _mesa_uniform_matrix(location, count, transpose, value, 840 ctx, ctx->_Shader->ActiveProgram, 4, 3, GLSL_TYPE_FLOAT); 841 } 842 843 /** Same as above with direct state access **/ 844 845 void GLAPIENTRY 846 _mesa_ProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, 847 GLboolean transpose, const GLfloat * value) 848 { 849 GET_CURRENT_CONTEXT(ctx); 850 struct gl_shader_program *shProg = 851 _mesa_lookup_shader_program_err(ctx, program, 852 "glProgramUniformMatrix2x3fv"); 853 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 2, 3, GLSL_TYPE_FLOAT); 854 } 855 856 void GLAPIENTRY 857 _mesa_ProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, 858 GLboolean transpose, const GLfloat * value) 859 { 860 GET_CURRENT_CONTEXT(ctx); 861 struct gl_shader_program *shProg = 862 _mesa_lookup_shader_program_err(ctx, program, 863 "glProgramUniformMatrix3x2fv"); 864 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 3, 2, GLSL_TYPE_FLOAT); 865 } 866 867 void GLAPIENTRY 868 _mesa_ProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, 869 GLboolean transpose, const GLfloat * value) 870 { 871 GET_CURRENT_CONTEXT(ctx); 872 struct gl_shader_program *shProg = 873 _mesa_lookup_shader_program_err(ctx, program, 874 "glProgramUniformMatrix2x4fv"); 875 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 2, 4, GLSL_TYPE_FLOAT); 876 } 877 878 void GLAPIENTRY 879 _mesa_ProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, 880 GLboolean transpose, const GLfloat * value) 881 { 882 GET_CURRENT_CONTEXT(ctx); 883 struct gl_shader_program *shProg = 884 _mesa_lookup_shader_program_err(ctx, program, 885 "glProgramUniformMatrix4x2fv"); 886 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 4, 2, GLSL_TYPE_FLOAT); 887 } 888 889 void GLAPIENTRY 890 _mesa_ProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, 891 GLboolean transpose, const GLfloat * value) 892 { 893 GET_CURRENT_CONTEXT(ctx); 894 struct gl_shader_program *shProg = 895 _mesa_lookup_shader_program_err(ctx, program, 896 "glProgramUniformMatrix3x4fv"); 897 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 3, 4, GLSL_TYPE_FLOAT); 898 } 899 900 void GLAPIENTRY 901 _mesa_ProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, 902 GLboolean transpose, const GLfloat * value) 903 { 904 GET_CURRENT_CONTEXT(ctx); 905 struct gl_shader_program *shProg = 906 _mesa_lookup_shader_program_err(ctx, program, 907 "glProgramUniformMatrix4x3fv"); 908 _mesa_uniform_matrix(location, count, transpose, value, ctx, shProg, 4, 3, GLSL_TYPE_FLOAT); 909 } 910 911 912 void GLAPIENTRY 913 _mesa_GetnUniformfvARB(GLuint program, GLint location, 914 GLsizei bufSize, GLfloat *params) 915 { 916 GET_CURRENT_CONTEXT(ctx); 917 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_FLOAT, params); 918 } 919 920 void GLAPIENTRY 921 _mesa_GetUniformfv(GLuint program, GLint location, GLfloat *params) 922 { 923 _mesa_GetnUniformfvARB(program, location, INT_MAX, params); 924 } 925 926 927 void GLAPIENTRY 928 _mesa_GetnUniformivARB(GLuint program, GLint location, 929 GLsizei bufSize, GLint *params) 930 { 931 GET_CURRENT_CONTEXT(ctx); 932 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT, params); 933 } 934 935 void GLAPIENTRY 936 _mesa_GetUniformiv(GLuint program, GLint location, GLint *params) 937 { 938 _mesa_GetnUniformivARB(program, location, INT_MAX, params); 939 } 940 941 942 /* GL3 */ 943 void GLAPIENTRY 944 _mesa_GetnUniformuivARB(GLuint program, GLint location, 945 GLsizei bufSize, GLuint *params) 946 { 947 GET_CURRENT_CONTEXT(ctx); 948 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT, params); 949 } 950 951 void GLAPIENTRY 952 _mesa_GetUniformuiv(GLuint program, GLint location, GLuint *params) 953 { 954 _mesa_GetnUniformuivARB(program, location, INT_MAX, params); 955 } 956 957 958 /* GL4 */ 959 void GLAPIENTRY 960 _mesa_GetnUniformdvARB(GLuint program, GLint location, 961 GLsizei bufSize, GLdouble *params) 962 { 963 GET_CURRENT_CONTEXT(ctx); 964 965 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_DOUBLE, params); 966 } 967 968 void GLAPIENTRY 969 _mesa_GetUniformdv(GLuint program, GLint location, GLdouble *params) 970 { 971 _mesa_GetnUniformdvARB(program, location, INT_MAX, params); 972 } 973 974 void GLAPIENTRY 975 _mesa_GetnUniformi64vARB(GLuint program, GLint location, 976 GLsizei bufSize, GLint64 *params) 977 { 978 GET_CURRENT_CONTEXT(ctx); 979 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_INT64, params); 980 } 981 void GLAPIENTRY 982 _mesa_GetUniformi64vARB(GLuint program, GLint location, GLint64 *params) 983 { 984 _mesa_GetnUniformi64vARB(program, location, INT_MAX, params); 985 } 986 987 void GLAPIENTRY 988 _mesa_GetnUniformui64vARB(GLuint program, GLint location, 989 GLsizei bufSize, GLuint64 *params) 990 { 991 GET_CURRENT_CONTEXT(ctx); 992 _mesa_get_uniform(ctx, program, location, bufSize, GLSL_TYPE_UINT64, params); 993 } 994 995 void GLAPIENTRY 996 _mesa_GetUniformui64vARB(GLuint program, GLint location, GLuint64 *params) 997 { 998 _mesa_GetnUniformui64vARB(program, location, INT_MAX, params); 999 } 1000 1001 1002 GLint GLAPIENTRY 1003 _mesa_GetUniformLocation(GLuint programObj, const GLcharARB *name) 1004 { 1005 struct gl_shader_program *shProg; 1006 1007 GET_CURRENT_CONTEXT(ctx); 1008 1009 shProg = _mesa_lookup_shader_program_err(ctx, programObj, 1010 "glGetUniformLocation"); 1011 if (!shProg) 1012 return -1; 1013 1014 /* Page 80 (page 94 of the PDF) of the OpenGL 2.1 spec says: 1015 * 1016 * "If program has not been successfully linked, the error 1017 * INVALID_OPERATION is generated." 1018 */ 1019 if (shProg->data->LinkStatus == linking_failure) { 1020 _mesa_error(ctx, GL_INVALID_OPERATION, 1021 "glGetUniformLocation(program not linked)"); 1022 return -1; 1023 } 1024 1025 return _mesa_program_resource_location(shProg, GL_UNIFORM, name); 1026 } 1027 1028 GLint GLAPIENTRY 1029 _mesa_GetUniformLocation_no_error(GLuint programObj, const GLcharARB *name) 1030 { 1031 GET_CURRENT_CONTEXT(ctx); 1032 1033 struct gl_shader_program *shProg = 1034 _mesa_lookup_shader_program(ctx, programObj); 1035 1036 return _mesa_program_resource_location(shProg, GL_UNIFORM, name); 1037 } 1038 1039 GLuint GLAPIENTRY 1040 _mesa_GetUniformBlockIndex(GLuint program, 1041 const GLchar *uniformBlockName) 1042 { 1043 GET_CURRENT_CONTEXT(ctx); 1044 struct gl_shader_program *shProg; 1045 1046 if (!ctx->Extensions.ARB_uniform_buffer_object) { 1047 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex"); 1048 return GL_INVALID_INDEX; 1049 } 1050 1051 shProg = _mesa_lookup_shader_program_err(ctx, program, 1052 "glGetUniformBlockIndex"); 1053 if (!shProg) 1054 return GL_INVALID_INDEX; 1055 1056 struct gl_program_resource *res = 1057 _mesa_program_resource_find_name(shProg, GL_UNIFORM_BLOCK, 1058 uniformBlockName, NULL); 1059 if (!res) 1060 return GL_INVALID_INDEX; 1061 1062 return _mesa_program_resource_index(shProg, res); 1063 } 1064 1065 void GLAPIENTRY 1066 _mesa_GetUniformIndices(GLuint program, 1067 GLsizei uniformCount, 1068 const GLchar * const *uniformNames, 1069 GLuint *uniformIndices) 1070 { 1071 GET_CURRENT_CONTEXT(ctx); 1072 GLsizei i; 1073 struct gl_shader_program *shProg; 1074 1075 if (!ctx->Extensions.ARB_uniform_buffer_object) { 1076 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices"); 1077 return; 1078 } 1079 1080 shProg = _mesa_lookup_shader_program_err(ctx, program, 1081 "glGetUniformIndices"); 1082 if (!shProg) 1083 return; 1084 1085 if (uniformCount < 0) { 1086 _mesa_error(ctx, GL_INVALID_VALUE, 1087 "glGetUniformIndices(uniformCount < 0)"); 1088 return; 1089 } 1090 1091 for (i = 0; i < uniformCount; i++) { 1092 struct gl_program_resource *res = 1093 _mesa_program_resource_find_name(shProg, GL_UNIFORM, uniformNames[i], 1094 NULL); 1095 uniformIndices[i] = _mesa_program_resource_index(shProg, res); 1096 } 1097 } 1098 1099 static void 1100 uniform_block_binding(struct gl_context *ctx, struct gl_shader_program *shProg, 1101 GLuint uniformBlockIndex, GLuint uniformBlockBinding) 1102 { 1103 if (shProg->data->UniformBlocks[uniformBlockIndex].Binding != 1104 uniformBlockBinding) { 1105 1106 FLUSH_VERTICES(ctx, 0); 1107 ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer; 1108 1109 shProg->data->UniformBlocks[uniformBlockIndex].Binding = 1110 uniformBlockBinding; 1111 } 1112 } 1113 1114 void GLAPIENTRY 1115 _mesa_UniformBlockBinding_no_error(GLuint program, GLuint uniformBlockIndex, 1116 GLuint uniformBlockBinding) 1117 { 1118 GET_CURRENT_CONTEXT(ctx); 1119 1120 struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, program); 1121 uniform_block_binding(ctx, shProg, uniformBlockIndex, uniformBlockBinding); 1122 } 1123 1124 void GLAPIENTRY 1125 _mesa_UniformBlockBinding(GLuint program, 1126 GLuint uniformBlockIndex, 1127 GLuint uniformBlockBinding) 1128 { 1129 GET_CURRENT_CONTEXT(ctx); 1130 struct gl_shader_program *shProg; 1131 1132 if (!ctx->Extensions.ARB_uniform_buffer_object) { 1133 _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformBlockBinding"); 1134 return; 1135 } 1136 1137 shProg = _mesa_lookup_shader_program_err(ctx, program, 1138 "glUniformBlockBinding"); 1139 if (!shProg) 1140 return; 1141 1142 if (uniformBlockIndex >= shProg->data->NumUniformBlocks) { 1143 _mesa_error(ctx, GL_INVALID_VALUE, 1144 "glUniformBlockBinding(block index %u >= %u)", 1145 uniformBlockIndex, shProg->data->NumUniformBlocks); 1146 return; 1147 } 1148 1149 if (uniformBlockBinding >= ctx->Const.MaxUniformBufferBindings) { 1150 _mesa_error(ctx, GL_INVALID_VALUE, 1151 "glUniformBlockBinding(block binding %u >= %u)", 1152 uniformBlockBinding, ctx->Const.MaxUniformBufferBindings); 1153 return; 1154 } 1155 1156 uniform_block_binding(ctx, shProg, uniformBlockIndex, uniformBlockBinding); 1157 } 1158 1159 static void 1160 shader_storage_block_binding(struct gl_context *ctx, 1161 struct gl_shader_program *shProg, 1162 GLuint shaderStorageBlockIndex, 1163 GLuint shaderStorageBlockBinding) 1164 { 1165 if (shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding != 1166 shaderStorageBlockBinding) { 1167 1168 FLUSH_VERTICES(ctx, 0); 1169 ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer; 1170 1171 shProg->data->ShaderStorageBlocks[shaderStorageBlockIndex].Binding = 1172 shaderStorageBlockBinding; 1173 } 1174 } 1175 1176 void GLAPIENTRY 1177 _mesa_ShaderStorageBlockBinding_no_error(GLuint program, 1178 GLuint shaderStorageBlockIndex, 1179 GLuint shaderStorageBlockBinding) 1180 { 1181 GET_CURRENT_CONTEXT(ctx); 1182 1183 struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, program); 1184 shader_storage_block_binding(ctx, shProg, shaderStorageBlockIndex, 1185 shaderStorageBlockBinding); 1186 } 1187 1188 void GLAPIENTRY 1189 _mesa_ShaderStorageBlockBinding(GLuint program, 1190 GLuint shaderStorageBlockIndex, 1191 GLuint shaderStorageBlockBinding) 1192 { 1193 GET_CURRENT_CONTEXT(ctx); 1194 struct gl_shader_program *shProg; 1195 1196 if (!ctx->Extensions.ARB_shader_storage_buffer_object) { 1197 _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderStorageBlockBinding"); 1198 return; 1199 } 1200 1201 shProg = _mesa_lookup_shader_program_err(ctx, program, 1202 "glShaderStorageBlockBinding"); 1203 if (!shProg) 1204 return; 1205 1206 if (shaderStorageBlockIndex >= shProg->data->NumShaderStorageBlocks) { 1207 _mesa_error(ctx, GL_INVALID_VALUE, 1208 "glShaderStorageBlockBinding(block index %u >= %u)", 1209 shaderStorageBlockIndex, 1210 shProg->data->NumShaderStorageBlocks); 1211 return; 1212 } 1213 1214 if (shaderStorageBlockBinding >= ctx->Const.MaxShaderStorageBufferBindings) { 1215 _mesa_error(ctx, GL_INVALID_VALUE, 1216 "glShaderStorageBlockBinding(block binding %u >= %u)", 1217 shaderStorageBlockBinding, 1218 ctx->Const.MaxShaderStorageBufferBindings); 1219 return; 1220 } 1221 1222 shader_storage_block_binding(ctx, shProg, shaderStorageBlockIndex, 1223 shaderStorageBlockBinding); 1224 } 1225 1226 /** 1227 * Generic program resource property query. 1228 */ 1229 static void 1230 mesa_bufferiv(struct gl_shader_program *shProg, GLenum type, 1231 GLuint index, GLenum pname, GLint *params, const char *caller) 1232 { 1233 GET_CURRENT_CONTEXT(ctx); 1234 struct gl_program_resource *res = 1235 _mesa_program_resource_find_index(shProg, type, index); 1236 1237 if (!res) { 1238 _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufferindex %d)", caller, index); 1239 return; 1240 } 1241 1242 switch (pname) { 1243 case GL_UNIFORM_BLOCK_BINDING: 1244 case GL_ATOMIC_COUNTER_BUFFER_BINDING: 1245 _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_BINDING, 1246 params, caller); 1247 return; 1248 case GL_UNIFORM_BLOCK_DATA_SIZE: 1249 case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE: 1250 _mesa_program_resource_prop(shProg, res, index, GL_BUFFER_DATA_SIZE, 1251 params, caller); 1252 return; 1253 case GL_UNIFORM_BLOCK_NAME_LENGTH: 1254 _mesa_program_resource_prop(shProg, res, index, GL_NAME_LENGTH, 1255 params, caller); 1256 return; 1257 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS: 1258 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS: 1259 _mesa_program_resource_prop(shProg, res, index, GL_NUM_ACTIVE_VARIABLES, 1260 params, caller); 1261 return; 1262 case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 1263 case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES: 1264 _mesa_program_resource_prop(shProg, res, index, GL_ACTIVE_VARIABLES, 1265 params, caller); 1266 return; 1267 case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 1268 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER: 1269 _mesa_program_resource_prop(shProg, res, index, 1270 GL_REFERENCED_BY_VERTEX_SHADER, params, 1271 caller); 1272 return; 1273 1274 case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER: 1275 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER: 1276 _mesa_program_resource_prop(shProg, res, index, 1277 GL_REFERENCED_BY_TESS_CONTROL_SHADER, params, 1278 caller); 1279 return; 1280 1281 case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER: 1282 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER: 1283 _mesa_program_resource_prop(shProg, res, index, 1284 GL_REFERENCED_BY_TESS_EVALUATION_SHADER, params, 1285 caller); 1286 return; 1287 1288 case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER: 1289 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER: 1290 _mesa_program_resource_prop(shProg, res, index, 1291 GL_REFERENCED_BY_GEOMETRY_SHADER, params, 1292 caller); 1293 return; 1294 case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 1295 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER: 1296 _mesa_program_resource_prop(shProg, res, index, 1297 GL_REFERENCED_BY_FRAGMENT_SHADER, params, 1298 caller); 1299 return; 1300 case GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER: 1301 case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER: 1302 _mesa_program_resource_prop(shProg, res, index, 1303 GL_REFERENCED_BY_COMPUTE_SHADER, params, 1304 caller); 1305 return; 1306 default: 1307 _mesa_error(ctx, GL_INVALID_ENUM, 1308 "%s(pname 0x%x (%s))", caller, pname, 1309 _mesa_enum_to_string(pname)); 1310 return; 1311 } 1312 } 1313 1314 1315 void GLAPIENTRY 1316 _mesa_GetActiveUniformBlockiv(GLuint program, 1317 GLuint uniformBlockIndex, 1318 GLenum pname, 1319 GLint *params) 1320 { 1321 GET_CURRENT_CONTEXT(ctx); 1322 struct gl_shader_program *shProg; 1323 1324 if (!ctx->Extensions.ARB_uniform_buffer_object) { 1325 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv"); 1326 return; 1327 } 1328 1329 shProg = _mesa_lookup_shader_program_err(ctx, program, 1330 "glGetActiveUniformBlockiv"); 1331 if (!shProg) 1332 return; 1333 1334 mesa_bufferiv(shProg, GL_UNIFORM_BLOCK, uniformBlockIndex, pname, params, 1335 "glGetActiveUniformBlockiv"); 1336 } 1337 1338 void GLAPIENTRY 1339 _mesa_GetActiveUniformBlockName(GLuint program, 1340 GLuint uniformBlockIndex, 1341 GLsizei bufSize, 1342 GLsizei *length, 1343 GLchar *uniformBlockName) 1344 { 1345 GET_CURRENT_CONTEXT(ctx); 1346 struct gl_shader_program *shProg; 1347 1348 if (!ctx->Extensions.ARB_uniform_buffer_object) { 1349 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformBlockiv"); 1350 return; 1351 } 1352 1353 if (bufSize < 0) { 1354 _mesa_error(ctx, GL_INVALID_VALUE, 1355 "glGetActiveUniformBlockName(bufSize %d < 0)", 1356 bufSize); 1357 return; 1358 } 1359 1360 shProg = _mesa_lookup_shader_program_err(ctx, program, 1361 "glGetActiveUniformBlockiv"); 1362 if (!shProg) 1363 return; 1364 1365 if (uniformBlockName) 1366 _mesa_get_program_resource_name(shProg, GL_UNIFORM_BLOCK, 1367 uniformBlockIndex, bufSize, length, 1368 uniformBlockName, 1369 "glGetActiveUniformBlockName"); 1370 } 1371 1372 void GLAPIENTRY 1373 _mesa_GetActiveUniformName(GLuint program, GLuint uniformIndex, 1374 GLsizei bufSize, GLsizei *length, 1375 GLchar *uniformName) 1376 { 1377 GET_CURRENT_CONTEXT(ctx); 1378 struct gl_shader_program *shProg; 1379 1380 if (!ctx->Extensions.ARB_uniform_buffer_object) { 1381 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetActiveUniformName"); 1382 return; 1383 } 1384 1385 if (bufSize < 0) { 1386 _mesa_error(ctx, GL_INVALID_VALUE, 1387 "glGetActiveUniformName(bufSize %d < 0)", 1388 bufSize); 1389 return; 1390 } 1391 1392 shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniformName"); 1393 1394 if (!shProg) 1395 return; 1396 1397 _mesa_get_program_resource_name(shProg, GL_UNIFORM, uniformIndex, bufSize, 1398 length, uniformName, "glGetActiveUniformName"); 1399 } 1400 1401 void GLAPIENTRY 1402 _mesa_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, 1403 GLenum pname, GLint *params) 1404 { 1405 GET_CURRENT_CONTEXT(ctx); 1406 struct gl_shader_program *shProg; 1407 1408 if (!ctx->Extensions.ARB_shader_atomic_counters) { 1409 _mesa_error(ctx, GL_INVALID_OPERATION, 1410 "glGetActiveAtomicCounterBufferiv"); 1411 return; 1412 } 1413 1414 shProg = _mesa_lookup_shader_program_err(ctx, program, 1415 "glGetActiveAtomicCounterBufferiv"); 1416 if (!shProg) 1417 return; 1418 1419 mesa_bufferiv(shProg, GL_ATOMIC_COUNTER_BUFFER, bufferIndex, pname, params, 1420 "glGetActiveAtomicCounterBufferiv"); 1421 } 1422 1423 void GLAPIENTRY 1424 _mesa_Uniform1d(GLint location, GLdouble v0) 1425 { 1426 GET_CURRENT_CONTEXT(ctx); 1427 _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 1); 1428 } 1429 1430 void GLAPIENTRY 1431 _mesa_Uniform2d(GLint location, GLdouble v0, GLdouble v1) 1432 { 1433 GET_CURRENT_CONTEXT(ctx); 1434 GLdouble v[2]; 1435 v[0] = v0; 1436 v[1] = v1; 1437 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 2); 1438 } 1439 1440 void GLAPIENTRY 1441 _mesa_Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2) 1442 { 1443 GET_CURRENT_CONTEXT(ctx); 1444 GLdouble v[3]; 1445 v[0] = v0; 1446 v[1] = v1; 1447 v[2] = v2; 1448 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 3); 1449 } 1450 1451 void GLAPIENTRY 1452 _mesa_Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2, 1453 GLdouble v3) 1454 { 1455 GET_CURRENT_CONTEXT(ctx); 1456 GLdouble v[4]; 1457 v[0] = v0; 1458 v[1] = v1; 1459 v[2] = v2; 1460 v[3] = v3; 1461 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 4); 1462 } 1463 1464 void GLAPIENTRY 1465 _mesa_Uniform1dv(GLint location, GLsizei count, const GLdouble * value) 1466 { 1467 GET_CURRENT_CONTEXT(ctx); 1468 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 1); 1469 } 1470 1471 void GLAPIENTRY 1472 _mesa_Uniform2dv(GLint location, GLsizei count, const GLdouble * value) 1473 { 1474 GET_CURRENT_CONTEXT(ctx); 1475 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 2); 1476 } 1477 1478 void GLAPIENTRY 1479 _mesa_Uniform3dv(GLint location, GLsizei count, const GLdouble * value) 1480 { 1481 GET_CURRENT_CONTEXT(ctx); 1482 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 3); 1483 } 1484 1485 void GLAPIENTRY 1486 _mesa_Uniform4dv(GLint location, GLsizei count, const GLdouble * value) 1487 { 1488 GET_CURRENT_CONTEXT(ctx); 1489 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_DOUBLE, 4); 1490 } 1491 1492 void GLAPIENTRY 1493 _mesa_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, 1494 const GLdouble * value) 1495 { 1496 GET_CURRENT_CONTEXT(ctx); 1497 _mesa_uniform_matrix(location, count, transpose, value, 1498 ctx, ctx->_Shader->ActiveProgram, 2, 2, GLSL_TYPE_DOUBLE); 1499 } 1500 1501 void GLAPIENTRY 1502 _mesa_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, 1503 const GLdouble * value) 1504 { 1505 GET_CURRENT_CONTEXT(ctx); 1506 _mesa_uniform_matrix(location, count, transpose, value, 1507 ctx, ctx->_Shader->ActiveProgram, 3, 3, GLSL_TYPE_DOUBLE); 1508 } 1509 1510 void GLAPIENTRY 1511 _mesa_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, 1512 const GLdouble * value) 1513 { 1514 GET_CURRENT_CONTEXT(ctx); 1515 _mesa_uniform_matrix(location, count, transpose, value, 1516 ctx, ctx->_Shader->ActiveProgram, 4, 4, GLSL_TYPE_DOUBLE); 1517 } 1518 1519 void GLAPIENTRY 1520 _mesa_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, 1521 const GLdouble *value) 1522 { 1523 GET_CURRENT_CONTEXT(ctx); 1524 _mesa_uniform_matrix(location, count, transpose, value, 1525 ctx, ctx->_Shader->ActiveProgram, 2, 3, GLSL_TYPE_DOUBLE); 1526 } 1527 1528 void GLAPIENTRY 1529 _mesa_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, 1530 const GLdouble *value) 1531 { 1532 GET_CURRENT_CONTEXT(ctx); 1533 _mesa_uniform_matrix(location, count, transpose, value, 1534 ctx, ctx->_Shader->ActiveProgram, 3, 2, GLSL_TYPE_DOUBLE); 1535 } 1536 1537 void GLAPIENTRY 1538 _mesa_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, 1539 const GLdouble *value) 1540 { 1541 GET_CURRENT_CONTEXT(ctx); 1542 _mesa_uniform_matrix(location, count, transpose, value, 1543 ctx, ctx->_Shader->ActiveProgram, 2, 4, GLSL_TYPE_DOUBLE); 1544 } 1545 1546 void GLAPIENTRY 1547 _mesa_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, 1548 const GLdouble *value) 1549 { 1550 GET_CURRENT_CONTEXT(ctx); 1551 _mesa_uniform_matrix(location, count, transpose, value, 1552 ctx, ctx->_Shader->ActiveProgram, 4, 2, GLSL_TYPE_DOUBLE); 1553 } 1554 1555 void GLAPIENTRY 1556 _mesa_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, 1557 const GLdouble *value) 1558 { 1559 GET_CURRENT_CONTEXT(ctx); 1560 _mesa_uniform_matrix(location, count, transpose, value, 1561 ctx, ctx->_Shader->ActiveProgram, 3, 4, GLSL_TYPE_DOUBLE); 1562 } 1563 1564 void GLAPIENTRY 1565 _mesa_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, 1566 const GLdouble *value) 1567 { 1568 GET_CURRENT_CONTEXT(ctx); 1569 _mesa_uniform_matrix(location, count, transpose, value, 1570 ctx, ctx->_Shader->ActiveProgram, 4, 3, GLSL_TYPE_DOUBLE); 1571 } 1572 1573 void GLAPIENTRY 1574 _mesa_ProgramUniform1d(GLuint program, GLint location, GLdouble v0) 1575 { 1576 GET_CURRENT_CONTEXT(ctx); 1577 struct gl_shader_program *shProg = 1578 _mesa_lookup_shader_program_err(ctx, program, 1579 "glProgramUniform1d"); 1580 _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_DOUBLE, 1); 1581 } 1582 1583 void GLAPIENTRY 1584 _mesa_ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1) 1585 { 1586 GET_CURRENT_CONTEXT(ctx); 1587 GLdouble v[2]; 1588 struct gl_shader_program *shProg; 1589 v[0] = v0; 1590 v[1] = v1; 1591 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform2d"); 1592 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 2); 1593 } 1594 1595 void GLAPIENTRY 1596 _mesa_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, 1597 GLdouble v2) 1598 { 1599 GET_CURRENT_CONTEXT(ctx); 1600 GLdouble v[3]; 1601 struct gl_shader_program *shProg; 1602 v[0] = v0; 1603 v[1] = v1; 1604 v[2] = v2; 1605 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform3d"); 1606 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 3); 1607 } 1608 1609 void GLAPIENTRY 1610 _mesa_ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, 1611 GLdouble v2, GLdouble v3) 1612 { 1613 GET_CURRENT_CONTEXT(ctx); 1614 GLdouble v[4]; 1615 struct gl_shader_program *shProg; 1616 v[0] = v0; 1617 v[1] = v1; 1618 v[2] = v2; 1619 v[3] = v3; 1620 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramUniform4d"); 1621 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_DOUBLE, 4); 1622 } 1623 1624 void GLAPIENTRY 1625 _mesa_ProgramUniform1dv(GLuint program, GLint location, GLsizei count, 1626 const GLdouble * value) 1627 { 1628 GET_CURRENT_CONTEXT(ctx); 1629 struct gl_shader_program *shProg = 1630 _mesa_lookup_shader_program_err(ctx, program, 1631 "glProgramUniform1dv"); 1632 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 1); 1633 } 1634 1635 void GLAPIENTRY 1636 _mesa_ProgramUniform2dv(GLuint program, GLint location, GLsizei count, 1637 const GLdouble * value) 1638 { 1639 GET_CURRENT_CONTEXT(ctx); 1640 struct gl_shader_program *shProg = 1641 _mesa_lookup_shader_program_err(ctx, program, 1642 "glProgramUniform2dv"); 1643 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 2); 1644 } 1645 1646 void GLAPIENTRY 1647 _mesa_ProgramUniform3dv(GLuint program, GLint location, GLsizei count, 1648 const GLdouble * value) 1649 { 1650 GET_CURRENT_CONTEXT(ctx); 1651 struct gl_shader_program *shProg = 1652 _mesa_lookup_shader_program_err(ctx, program, 1653 "glProgramUniform3dv"); 1654 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 3); 1655 } 1656 1657 void GLAPIENTRY 1658 _mesa_ProgramUniform4dv(GLuint program, GLint location, GLsizei count, 1659 const GLdouble * value) 1660 { 1661 GET_CURRENT_CONTEXT(ctx); 1662 struct gl_shader_program *shProg = 1663 _mesa_lookup_shader_program_err(ctx, program, 1664 "glProgramUniform4dv"); 1665 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_DOUBLE, 4); 1666 } 1667 1668 void GLAPIENTRY 1669 _mesa_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, 1670 GLboolean transpose, const GLdouble * value) 1671 { 1672 GET_CURRENT_CONTEXT(ctx); 1673 struct gl_shader_program *shProg = 1674 _mesa_lookup_shader_program_err(ctx, program, 1675 "glProgramUniformMatrix2dv"); 1676 _mesa_uniform_matrix(location, count, transpose, value, 1677 ctx, shProg, 2, 2, GLSL_TYPE_DOUBLE); 1678 } 1679 1680 void GLAPIENTRY 1681 _mesa_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, 1682 GLboolean transpose, const GLdouble * value) 1683 { 1684 GET_CURRENT_CONTEXT(ctx); 1685 struct gl_shader_program *shProg = 1686 _mesa_lookup_shader_program_err(ctx, program, 1687 "glProgramUniformMatrix3dv"); 1688 _mesa_uniform_matrix(location, count, transpose, value, 1689 ctx, shProg, 3, 3, GLSL_TYPE_DOUBLE); 1690 } 1691 1692 void GLAPIENTRY 1693 _mesa_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, 1694 GLboolean transpose, const GLdouble * value) 1695 { 1696 GET_CURRENT_CONTEXT(ctx); 1697 struct gl_shader_program *shProg = 1698 _mesa_lookup_shader_program_err(ctx, program, 1699 "glProgramUniformMatrix4dv"); 1700 _mesa_uniform_matrix(location, count, transpose, value, 1701 ctx, shProg, 4, 4, GLSL_TYPE_DOUBLE); 1702 } 1703 1704 void GLAPIENTRY 1705 _mesa_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, 1706 GLboolean transpose, const GLdouble * value) 1707 { 1708 GET_CURRENT_CONTEXT(ctx); 1709 struct gl_shader_program *shProg = 1710 _mesa_lookup_shader_program_err(ctx, program, 1711 "glProgramUniformMatrix2x3dv"); 1712 _mesa_uniform_matrix(location, count, transpose, value, 1713 ctx, shProg, 2, 3, GLSL_TYPE_DOUBLE); 1714 } 1715 1716 void GLAPIENTRY 1717 _mesa_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, 1718 GLboolean transpose, const GLdouble * value) 1719 { 1720 GET_CURRENT_CONTEXT(ctx); 1721 struct gl_shader_program *shProg = 1722 _mesa_lookup_shader_program_err(ctx, program, 1723 "glProgramUniformMatrix3x2dv"); 1724 _mesa_uniform_matrix(location, count, transpose, value, 1725 ctx, shProg, 3, 2, GLSL_TYPE_DOUBLE); 1726 } 1727 1728 void GLAPIENTRY 1729 _mesa_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, 1730 GLboolean transpose, const GLdouble * value) 1731 { 1732 GET_CURRENT_CONTEXT(ctx); 1733 struct gl_shader_program *shProg = 1734 _mesa_lookup_shader_program_err(ctx, program, 1735 "glProgramUniformMatrix2x4dv"); 1736 _mesa_uniform_matrix(location, count, transpose, value, 1737 ctx, shProg, 2, 4, GLSL_TYPE_DOUBLE); 1738 } 1739 1740 void GLAPIENTRY 1741 _mesa_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, 1742 GLboolean transpose, const GLdouble * value) 1743 { 1744 GET_CURRENT_CONTEXT(ctx); 1745 struct gl_shader_program *shProg = 1746 _mesa_lookup_shader_program_err(ctx, program, 1747 "glProgramUniformMatrix4x2dv"); 1748 _mesa_uniform_matrix(location, count, transpose, value, 1749 ctx, shProg, 4, 2, GLSL_TYPE_DOUBLE); 1750 } 1751 1752 void GLAPIENTRY 1753 _mesa_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, 1754 GLboolean transpose, const GLdouble * value) 1755 { 1756 GET_CURRENT_CONTEXT(ctx); 1757 struct gl_shader_program *shProg = 1758 _mesa_lookup_shader_program_err(ctx, program, 1759 "glProgramUniformMatrix3x4dv"); 1760 _mesa_uniform_matrix(location, count, transpose, value, 1761 ctx, shProg, 3, 4, GLSL_TYPE_DOUBLE); 1762 } 1763 1764 void GLAPIENTRY 1765 _mesa_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, 1766 GLboolean transpose, const GLdouble * value) 1767 { 1768 GET_CURRENT_CONTEXT(ctx); 1769 struct gl_shader_program *shProg = 1770 _mesa_lookup_shader_program_err(ctx, program, 1771 "glProgramUniformMatrix4x3dv"); 1772 _mesa_uniform_matrix(location, count, transpose, value, 1773 ctx, shProg, 4, 3, GLSL_TYPE_DOUBLE); 1774 } 1775 1776 void GLAPIENTRY 1777 _mesa_Uniform1i64ARB(GLint location, GLint64 v0) 1778 { 1779 GET_CURRENT_CONTEXT(ctx); 1780 _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 1); 1781 } 1782 1783 void GLAPIENTRY 1784 _mesa_Uniform2i64ARB(GLint location, GLint64 v0, GLint64 v1) 1785 { 1786 GET_CURRENT_CONTEXT(ctx); 1787 int64_t v[2]; 1788 v[0] = v0; 1789 v[1] = v1; 1790 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 2); 1791 } 1792 1793 void GLAPIENTRY 1794 _mesa_Uniform3i64ARB(GLint location, GLint64 v0, GLint64 v1, GLint64 v2) 1795 { 1796 GET_CURRENT_CONTEXT(ctx); 1797 int64_t v[3]; 1798 v[0] = v0; 1799 v[1] = v1; 1800 v[2] = v2; 1801 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 3); 1802 } 1803 1804 void GLAPIENTRY 1805 _mesa_Uniform4i64ARB(GLint location, GLint64 v0, GLint64 v1, GLint64 v2, GLint64 v3) 1806 { 1807 GET_CURRENT_CONTEXT(ctx); 1808 int64_t v[4]; 1809 v[0] = v0; 1810 v[1] = v1; 1811 v[2] = v2; 1812 v[3] = v3; 1813 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 4); 1814 } 1815 1816 void GLAPIENTRY 1817 _mesa_Uniform1i64vARB(GLint location, GLsizei count, const GLint64 *value) 1818 { 1819 GET_CURRENT_CONTEXT(ctx); 1820 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 1); 1821 } 1822 1823 void GLAPIENTRY 1824 _mesa_Uniform2i64vARB(GLint location, GLsizei count, const GLint64 *value) 1825 { 1826 GET_CURRENT_CONTEXT(ctx); 1827 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 2); 1828 } 1829 1830 void GLAPIENTRY 1831 _mesa_Uniform3i64vARB(GLint location, GLsizei count, const GLint64 *value) 1832 { 1833 GET_CURRENT_CONTEXT(ctx); 1834 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 3); 1835 } 1836 1837 void GLAPIENTRY 1838 _mesa_Uniform4i64vARB(GLint location, GLsizei count, const GLint64 *value) 1839 { 1840 GET_CURRENT_CONTEXT(ctx); 1841 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_INT64, 4); 1842 } 1843 1844 void GLAPIENTRY 1845 _mesa_Uniform1ui64ARB(GLint location, GLuint64 v0) 1846 { 1847 GET_CURRENT_CONTEXT(ctx); 1848 _mesa_uniform(location, 1, &v0, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 1); 1849 } 1850 1851 void GLAPIENTRY 1852 _mesa_Uniform2ui64ARB(GLint location, GLuint64 v0, GLuint64 v1) 1853 { 1854 GET_CURRENT_CONTEXT(ctx); 1855 uint64_t v[2]; 1856 v[0] = v0; 1857 v[1] = v1; 1858 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 2); 1859 } 1860 1861 void GLAPIENTRY 1862 _mesa_Uniform3ui64ARB(GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2) 1863 { 1864 GET_CURRENT_CONTEXT(ctx); 1865 uint64_t v[3]; 1866 v[0] = v0; 1867 v[1] = v1; 1868 v[2] = v2; 1869 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 3); 1870 } 1871 1872 void GLAPIENTRY 1873 _mesa_Uniform4ui64ARB(GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2, GLuint64 v3) 1874 { 1875 GET_CURRENT_CONTEXT(ctx); 1876 uint64_t v[4]; 1877 v[0] = v0; 1878 v[1] = v1; 1879 v[2] = v2; 1880 v[3] = v3; 1881 _mesa_uniform(location, 1, v, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 4); 1882 } 1883 1884 void GLAPIENTRY 1885 _mesa_Uniform1ui64vARB(GLint location, GLsizei count, const GLuint64 *value) 1886 { 1887 GET_CURRENT_CONTEXT(ctx); 1888 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 1); 1889 } 1890 1891 void GLAPIENTRY 1892 _mesa_Uniform2ui64vARB(GLint location, GLsizei count, const GLuint64 *value) 1893 { 1894 GET_CURRENT_CONTEXT(ctx); 1895 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 2); 1896 } 1897 1898 void GLAPIENTRY 1899 _mesa_Uniform3ui64vARB(GLint location, GLsizei count, const GLuint64 *value) 1900 { 1901 GET_CURRENT_CONTEXT(ctx); 1902 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 3); 1903 } 1904 1905 void GLAPIENTRY 1906 _mesa_Uniform4ui64vARB(GLint location, GLsizei count, const GLuint64 *value) 1907 { 1908 GET_CURRENT_CONTEXT(ctx); 1909 _mesa_uniform(location, count, value, ctx, ctx->_Shader->ActiveProgram, GLSL_TYPE_UINT64, 4); 1910 } 1911 1912 /* DSA entrypoints */ 1913 void GLAPIENTRY 1914 _mesa_ProgramUniform1i64ARB(GLuint program, GLint location, GLint64 v0) 1915 { 1916 GET_CURRENT_CONTEXT(ctx); 1917 struct gl_shader_program *shProg = 1918 _mesa_lookup_shader_program_err(ctx, program, 1919 "glProgramUniform1i64ARB"); 1920 _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_INT64, 1); 1921 } 1922 1923 void GLAPIENTRY 1924 _mesa_ProgramUniform2i64ARB(GLuint program, GLint location, GLint64 v0, GLint64 v1) 1925 { 1926 GET_CURRENT_CONTEXT(ctx); 1927 struct gl_shader_program *shProg = 1928 _mesa_lookup_shader_program_err(ctx, program, 1929 "glProgramUniform2i64ARB"); 1930 int64_t v[2]; 1931 v[0] = v0; 1932 v[1] = v1; 1933 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 2); 1934 } 1935 1936 void GLAPIENTRY 1937 _mesa_ProgramUniform3i64ARB(GLuint program, GLint location, GLint64 v0, GLint64 v1, GLint64 v2) 1938 { 1939 GET_CURRENT_CONTEXT(ctx); 1940 struct gl_shader_program *shProg = 1941 _mesa_lookup_shader_program_err(ctx, program, 1942 "glProgramUniform3i64ARB"); 1943 int64_t v[3]; 1944 v[0] = v0; 1945 v[1] = v1; 1946 v[2] = v2; 1947 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 3); 1948 } 1949 1950 void GLAPIENTRY 1951 _mesa_ProgramUniform4i64ARB(GLuint program, GLint location, GLint64 v0, GLint64 v1, GLint64 v2, GLint64 v3) 1952 { 1953 GET_CURRENT_CONTEXT(ctx); 1954 struct gl_shader_program *shProg = 1955 _mesa_lookup_shader_program_err(ctx, program, 1956 "glProgramUniform4i64ARB"); 1957 int64_t v[4]; 1958 v[0] = v0; 1959 v[1] = v1; 1960 v[2] = v2; 1961 v[3] = v3; 1962 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_INT64, 4); 1963 } 1964 1965 void GLAPIENTRY 1966 _mesa_ProgramUniform1i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value) 1967 { 1968 GET_CURRENT_CONTEXT(ctx); 1969 struct gl_shader_program *shProg = 1970 _mesa_lookup_shader_program_err(ctx, program, 1971 "glProgramUniform1i64vARB"); 1972 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 1); 1973 } 1974 1975 void GLAPIENTRY 1976 _mesa_ProgramUniform2i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value) 1977 { 1978 GET_CURRENT_CONTEXT(ctx); 1979 struct gl_shader_program *shProg = 1980 _mesa_lookup_shader_program_err(ctx, program, 1981 "glProgramUniform2i64vARB"); 1982 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 2); 1983 } 1984 1985 void GLAPIENTRY 1986 _mesa_ProgramUniform3i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value) 1987 { 1988 GET_CURRENT_CONTEXT(ctx); 1989 struct gl_shader_program *shProg = 1990 _mesa_lookup_shader_program_err(ctx, program, 1991 "glProgramUniform3i64vARB"); 1992 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 3); 1993 } 1994 1995 void GLAPIENTRY 1996 _mesa_ProgramUniform4i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value) 1997 { 1998 GET_CURRENT_CONTEXT(ctx); 1999 struct gl_shader_program *shProg = 2000 _mesa_lookup_shader_program_err(ctx, program, 2001 "glProgramUniform4i64vARB"); 2002 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_INT64, 4); 2003 } 2004 2005 void GLAPIENTRY 2006 _mesa_ProgramUniform1ui64ARB(GLuint program, GLint location, GLuint64 v0) 2007 { 2008 GET_CURRENT_CONTEXT(ctx); 2009 struct gl_shader_program *shProg = 2010 _mesa_lookup_shader_program_err(ctx, program, 2011 "glProgramUniform1ui64ARB"); 2012 _mesa_uniform(location, 1, &v0, ctx, shProg, GLSL_TYPE_UINT64, 1); 2013 } 2014 2015 void GLAPIENTRY 2016 _mesa_ProgramUniform2ui64ARB(GLuint program, GLint location, GLuint64 v0, GLuint64 v1) 2017 { 2018 GET_CURRENT_CONTEXT(ctx); 2019 struct gl_shader_program *shProg = 2020 _mesa_lookup_shader_program_err(ctx, program, 2021 "glProgramUniform2ui64ARB"); 2022 uint64_t v[2]; 2023 v[0] = v0; 2024 v[1] = v1; 2025 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 2); 2026 } 2027 2028 void GLAPIENTRY 2029 _mesa_ProgramUniform3ui64ARB(GLuint program, GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2) 2030 { 2031 GET_CURRENT_CONTEXT(ctx); 2032 struct gl_shader_program *shProg = 2033 _mesa_lookup_shader_program_err(ctx, program, 2034 "glProgramUniform3ui64ARB"); 2035 uint64_t v[3]; 2036 v[0] = v0; 2037 v[1] = v1; 2038 v[2] = v2; 2039 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 3); 2040 } 2041 2042 void GLAPIENTRY 2043 _mesa_ProgramUniform4ui64ARB(GLuint program, GLint location, GLuint64 v0, GLuint64 v1, GLuint64 v2, GLuint64 v3) 2044 { 2045 GET_CURRENT_CONTEXT(ctx); 2046 struct gl_shader_program *shProg = 2047 _mesa_lookup_shader_program_err(ctx, program, 2048 "glProgramUniform4ui64ARB"); 2049 uint64_t v[4]; 2050 v[0] = v0; 2051 v[1] = v1; 2052 v[2] = v2; 2053 v[3] = v3; 2054 _mesa_uniform(location, 1, v, ctx, shProg, GLSL_TYPE_UINT64, 4); 2055 } 2056 2057 void GLAPIENTRY 2058 _mesa_ProgramUniform1ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value) 2059 { 2060 GET_CURRENT_CONTEXT(ctx); 2061 struct gl_shader_program *shProg = 2062 _mesa_lookup_shader_program_err(ctx, program, 2063 "glProgramUniform1ui64vARB"); 2064 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 1); 2065 } 2066 2067 void GLAPIENTRY 2068 _mesa_ProgramUniform2ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value) 2069 { 2070 GET_CURRENT_CONTEXT(ctx); 2071 struct gl_shader_program *shProg = 2072 _mesa_lookup_shader_program_err(ctx, program, 2073 "glProgramUniform2ui64vARB"); 2074 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 2); 2075 } 2076 2077 void GLAPIENTRY 2078 _mesa_ProgramUniform3ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value) 2079 { 2080 GET_CURRENT_CONTEXT(ctx); 2081 struct gl_shader_program *shProg = 2082 _mesa_lookup_shader_program_err(ctx, program, 2083 "glProgramUniform3ui64vARB"); 2084 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 3); 2085 } 2086 2087 void GLAPIENTRY 2088 _mesa_ProgramUniform4ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value) 2089 { 2090 GET_CURRENT_CONTEXT(ctx); 2091 struct gl_shader_program *shProg = 2092 _mesa_lookup_shader_program_err(ctx, program, 2093 "glProgramUniform4ui64vARB"); 2094 _mesa_uniform(location, count, value, ctx, shProg, GLSL_TYPE_UINT64, 4); 2095 } 2096
