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 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 /** 26 * \file shaderapi.c 27 * \author Brian Paul 28 * 29 * Implementation of GLSL-related API functions. 30 * The glUniform* functions are in uniforms.c 31 * 32 * 33 * XXX things to do: 34 * 1. Check that the right error code is generated for all _mesa_error() calls. 35 * 2. Insert FLUSH_VERTICES calls in various places 36 */ 37 38 39 #include "main/glheader.h" 40 #include "main/context.h" 41 #include "main/dispatch.h" 42 #include "main/enums.h" 43 #include "main/hash.h" 44 #include "main/mfeatures.h" 45 #include "main/mtypes.h" 46 #include "main/shaderapi.h" 47 #include "main/shaderobj.h" 48 #include "main/uniforms.h" 49 #include "program/program.h" 50 #include "program/prog_parameter.h" 51 #include "ralloc.h" 52 #include <stdbool.h> 53 #include "../glsl/glsl_parser_extras.h" 54 #include "../glsl/ir_uniform.h" 55 56 /** Define this to enable shader substitution (see below) */ 57 #define SHADER_SUBST 0 58 59 60 /** 61 * Return mask of GLSL_x flags by examining the MESA_GLSL env var. 62 */ 63 static GLbitfield 64 get_shader_flags(void) 65 { 66 GLbitfield flags = 0x0; 67 const char *env = _mesa_getenv("MESA_GLSL"); 68 69 if (env) { 70 if (strstr(env, "dump")) 71 flags |= GLSL_DUMP; 72 if (strstr(env, "log")) 73 flags |= GLSL_LOG; 74 if (strstr(env, "nopvert")) 75 flags |= GLSL_NOP_VERT; 76 if (strstr(env, "nopfrag")) 77 flags |= GLSL_NOP_FRAG; 78 if (strstr(env, "nopt")) 79 flags |= GLSL_NO_OPT; 80 else if (strstr(env, "opt")) 81 flags |= GLSL_OPT; 82 if (strstr(env, "uniform")) 83 flags |= GLSL_UNIFORMS; 84 if (strstr(env, "useprog")) 85 flags |= GLSL_USE_PROG; 86 if (strstr(env, "errors")) 87 flags |= GLSL_REPORT_ERRORS; 88 } 89 90 return flags; 91 } 92 93 94 /** 95 * Initialize context's shader state. 96 */ 97 void 98 _mesa_init_shader_state(struct gl_context *ctx) 99 { 100 /* Device drivers may override these to control what kind of instructions 101 * are generated by the GLSL compiler. 102 */ 103 struct gl_shader_compiler_options options; 104 gl_shader_type sh; 105 106 memset(&options, 0, sizeof(options)); 107 options.MaxUnrollIterations = 32; 108 options.MaxIfDepth = UINT_MAX; 109 110 /* Default pragma settings */ 111 options.DefaultPragmas.Optimize = GL_TRUE; 112 113 for (sh = 0; sh < MESA_SHADER_TYPES; ++sh) 114 memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options)); 115 116 ctx->Shader.Flags = get_shader_flags(); 117 } 118 119 120 /** 121 * Free the per-context shader-related state. 122 */ 123 void 124 _mesa_free_shader_state(struct gl_context *ctx) 125 { 126 _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL); 127 _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram, 128 NULL); 129 _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram, 130 NULL); 131 _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram, 132 NULL); 133 _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL); 134 } 135 136 137 /** 138 * Copy string from <src> to <dst>, up to maxLength characters, returning 139 * length of <dst> in <length>. 140 * \param src the strings source 141 * \param maxLength max chars to copy 142 * \param length returns number of chars copied 143 * \param dst the string destination 144 */ 145 void 146 _mesa_copy_string(GLchar *dst, GLsizei maxLength, 147 GLsizei *length, const GLchar *src) 148 { 149 GLsizei len; 150 for (len = 0; len < maxLength - 1 && src && src[len]; len++) 151 dst[len] = src[len]; 152 if (maxLength > 0) 153 dst[len] = 0; 154 if (length) 155 *length = len; 156 } 157 158 159 160 /** 161 * Confirm that the a shader type is valid and supported by the implementation 162 * 163 * \param ctx Current GL context 164 * \param type Shader target 165 * 166 */ 167 static bool 168 validate_shader_target(const struct gl_context *ctx, GLenum type) 169 { 170 switch (type) { 171 #if FEATURE_ARB_fragment_shader 172 case GL_FRAGMENT_SHADER: 173 return ctx->Extensions.ARB_fragment_shader; 174 #endif 175 #if FEATURE_ARB_vertex_shader 176 case GL_VERTEX_SHADER: 177 return ctx->Extensions.ARB_vertex_shader; 178 #endif 179 #if FEATURE_ARB_geometry_shader4 180 case GL_GEOMETRY_SHADER_ARB: 181 return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_geometry_shader4; 182 #endif 183 default: 184 return false; 185 } 186 } 187 188 189 static GLboolean 190 is_program(struct gl_context *ctx, GLuint name) 191 { 192 struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name); 193 return shProg ? GL_TRUE : GL_FALSE; 194 } 195 196 197 static GLboolean 198 is_shader(struct gl_context *ctx, GLuint name) 199 { 200 struct gl_shader *shader = _mesa_lookup_shader(ctx, name); 201 return shader ? GL_TRUE : GL_FALSE; 202 } 203 204 205 /** 206 * Attach shader to a shader program. 207 */ 208 static void 209 attach_shader(struct gl_context *ctx, GLuint program, GLuint shader) 210 { 211 struct gl_shader_program *shProg; 212 struct gl_shader *sh; 213 GLuint i, n; 214 215 shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader"); 216 if (!shProg) 217 return; 218 219 sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader"); 220 if (!sh) { 221 return; 222 } 223 224 n = shProg->NumShaders; 225 for (i = 0; i < n; i++) { 226 if (shProg->Shaders[i] == sh) { 227 /* The shader is already attched to this program. The 228 * GL_ARB_shader_objects spec says: 229 * 230 * "The error INVALID_OPERATION is generated by AttachObjectARB 231 * if <obj> is already attached to <containerObj>." 232 */ 233 _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader"); 234 return; 235 } 236 } 237 238 /* grow list */ 239 shProg->Shaders = (struct gl_shader **) 240 _mesa_realloc(shProg->Shaders, 241 n * sizeof(struct gl_shader *), 242 (n + 1) * sizeof(struct gl_shader *)); 243 if (!shProg->Shaders) { 244 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader"); 245 return; 246 } 247 248 /* append */ 249 shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */ 250 _mesa_reference_shader(ctx, &shProg->Shaders[n], sh); 251 shProg->NumShaders++; 252 } 253 254 255 static GLuint 256 create_shader(struct gl_context *ctx, GLenum type) 257 { 258 struct gl_shader *sh; 259 GLuint name; 260 261 if (!validate_shader_target(ctx, type)) { 262 _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)"); 263 return 0; 264 } 265 266 name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1); 267 sh = ctx->Driver.NewShader(ctx, name, type); 268 _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh); 269 270 return name; 271 } 272 273 274 static GLuint 275 create_shader_program(struct gl_context *ctx) 276 { 277 GLuint name; 278 struct gl_shader_program *shProg; 279 280 name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1); 281 282 shProg = ctx->Driver.NewShaderProgram(ctx, name); 283 284 _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg); 285 286 assert(shProg->RefCount == 1); 287 288 return name; 289 } 290 291 292 /** 293 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's 294 * DeleteProgramARB. 295 */ 296 static void 297 delete_shader_program(struct gl_context *ctx, GLuint name) 298 { 299 /* 300 * NOTE: deleting shaders/programs works a bit differently than 301 * texture objects (and buffer objects, etc). Shader/program 302 * handles/IDs exist in the hash table until the object is really 303 * deleted (refcount==0). With texture objects, the handle/ID is 304 * removed from the hash table in glDeleteTextures() while the tex 305 * object itself might linger until its refcount goes to zero. 306 */ 307 struct gl_shader_program *shProg; 308 309 shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram"); 310 if (!shProg) 311 return; 312 313 if (!shProg->DeletePending) { 314 shProg->DeletePending = GL_TRUE; 315 316 /* effectively, decr shProg's refcount */ 317 _mesa_reference_shader_program(ctx, &shProg, NULL); 318 } 319 } 320 321 322 static void 323 delete_shader(struct gl_context *ctx, GLuint shader) 324 { 325 struct gl_shader *sh; 326 327 sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader"); 328 if (!sh) 329 return; 330 331 if (!sh->DeletePending) { 332 sh->DeletePending = GL_TRUE; 333 334 /* effectively, decr sh's refcount */ 335 _mesa_reference_shader(ctx, &sh, NULL); 336 } 337 } 338 339 340 static void 341 detach_shader(struct gl_context *ctx, GLuint program, GLuint shader) 342 { 343 struct gl_shader_program *shProg; 344 GLuint n; 345 GLuint i, j; 346 347 shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader"); 348 if (!shProg) 349 return; 350 351 n = shProg->NumShaders; 352 353 for (i = 0; i < n; i++) { 354 if (shProg->Shaders[i]->Name == shader) { 355 /* found it */ 356 struct gl_shader **newList; 357 358 /* release */ 359 _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL); 360 361 /* alloc new, smaller array */ 362 newList = (struct gl_shader **) 363 malloc((n - 1) * sizeof(struct gl_shader *)); 364 if (!newList) { 365 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader"); 366 return; 367 } 368 for (j = 0; j < i; j++) { 369 newList[j] = shProg->Shaders[j]; 370 } 371 while (++i < n) 372 newList[j++] = shProg->Shaders[i]; 373 free(shProg->Shaders); 374 375 shProg->Shaders = newList; 376 shProg->NumShaders = n - 1; 377 378 #ifdef DEBUG 379 /* sanity check */ 380 { 381 for (j = 0; j < shProg->NumShaders; j++) { 382 assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER || 383 shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER); 384 assert(shProg->Shaders[j]->RefCount > 0); 385 } 386 } 387 #endif 388 389 return; 390 } 391 } 392 393 /* not found */ 394 { 395 GLenum err; 396 if (is_shader(ctx, shader)) 397 err = GL_INVALID_OPERATION; 398 else if (is_program(ctx, shader)) 399 err = GL_INVALID_OPERATION; 400 else 401 err = GL_INVALID_VALUE; 402 _mesa_error(ctx, err, "glDetachProgram(shader)"); 403 return; 404 } 405 } 406 407 408 /** 409 * Return list of shaders attached to shader program. 410 */ 411 static void 412 get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount, 413 GLsizei *count, GLuint *obj) 414 { 415 struct gl_shader_program *shProg = 416 _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders"); 417 if (shProg) { 418 GLuint i; 419 for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) { 420 obj[i] = shProg->Shaders[i]->Name; 421 } 422 if (count) 423 *count = i; 424 } 425 } 426 427 428 /** 429 * glGetHandleARB() - return ID/name of currently bound shader program. 430 */ 431 static GLuint 432 get_handle(struct gl_context *ctx, GLenum pname) 433 { 434 if (pname == GL_PROGRAM_OBJECT_ARB) { 435 if (ctx->Shader.ActiveProgram) 436 return ctx->Shader.ActiveProgram->Name; 437 else 438 return 0; 439 } 440 else { 441 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB"); 442 return 0; 443 } 444 } 445 446 447 /** 448 * glGetProgramiv() - get shader program state. 449 * Note that this is for GLSL shader programs, not ARB vertex/fragment 450 * programs (see glGetProgramivARB). 451 */ 452 static void 453 get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params) 454 { 455 struct gl_shader_program *shProg 456 = _mesa_lookup_shader_program(ctx, program); 457 458 #if FEATURE_EXT_transform_feedback 459 /* Is transform feedback available in this context? 460 */ 461 const bool has_xfb = 462 (ctx->API == API_OPENGL && ctx->Extensions.EXT_transform_feedback) 463 || ctx->API == API_OPENGL_CORE 464 || _mesa_is_gles3(ctx); 465 #endif 466 467 #if FEATURE_ARB_geometry_shader4 468 /* Are geometry shaders available in this context? 469 */ 470 const bool has_gs = 471 _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_geometry_shader4; 472 #endif 473 474 /* Are uniform buffer objects available in this context? 475 */ 476 const bool has_ubo = 477 (ctx->API == API_OPENGL && ctx->Extensions.ARB_uniform_buffer_object) 478 || ctx->API == API_OPENGL_CORE 479 || _mesa_is_gles3(ctx); 480 481 if (!shProg) { 482 _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)"); 483 return; 484 } 485 486 switch (pname) { 487 case GL_DELETE_STATUS: 488 *params = shProg->DeletePending; 489 return; 490 case GL_LINK_STATUS: 491 *params = shProg->LinkStatus; 492 return; 493 case GL_VALIDATE_STATUS: 494 *params = shProg->Validated; 495 return; 496 case GL_INFO_LOG_LENGTH: 497 *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0; 498 return; 499 case GL_ATTACHED_SHADERS: 500 *params = shProg->NumShaders; 501 return; 502 case GL_ACTIVE_ATTRIBUTES: 503 *params = _mesa_count_active_attribs(shProg); 504 return; 505 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: 506 *params = _mesa_longest_attribute_name_length(shProg); 507 return; 508 case GL_ACTIVE_UNIFORMS: 509 *params = shProg->NumUserUniformStorage; 510 return; 511 case GL_ACTIVE_UNIFORM_MAX_LENGTH: { 512 unsigned i; 513 GLint max_len = 0; 514 515 for (i = 0; i < shProg->NumUserUniformStorage; i++) { 516 /* Add one for the terminating NUL character. 517 */ 518 const GLint len = strlen(shProg->UniformStorage[i].name) + 1; 519 520 if (len > max_len) 521 max_len = len; 522 } 523 524 *params = max_len; 525 return; 526 } 527 #if FEATURE_EXT_transform_feedback 528 case GL_TRANSFORM_FEEDBACK_VARYINGS: 529 if (!has_xfb) 530 break; 531 *params = shProg->TransformFeedback.NumVarying; 532 return; 533 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: { 534 unsigned i; 535 GLint max_len = 0; 536 if (!has_xfb) 537 break; 538 539 for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) { 540 /* Add one for the terminating NUL character. 541 */ 542 const GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]) + 1; 543 544 if (len > max_len) 545 max_len = len; 546 } 547 548 *params = max_len; 549 return; 550 } 551 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE: 552 if (!has_xfb) 553 break; 554 *params = shProg->TransformFeedback.BufferMode; 555 return; 556 #endif 557 #if FEATURE_ARB_geometry_shader4 558 case GL_GEOMETRY_VERTICES_OUT_ARB: 559 if (!has_gs) 560 break; 561 *params = shProg->Geom.VerticesOut; 562 return; 563 case GL_GEOMETRY_INPUT_TYPE_ARB: 564 if (!has_gs) 565 break; 566 *params = shProg->Geom.InputType; 567 return; 568 case GL_GEOMETRY_OUTPUT_TYPE_ARB: 569 if (!has_gs) 570 break; 571 *params = shProg->Geom.OutputType; 572 return; 573 #endif 574 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: { 575 unsigned i; 576 GLint max_len = 0; 577 578 if (!has_ubo) 579 break; 580 581 for (i = 0; i < shProg->NumUniformBlocks; i++) { 582 /* Add one for the terminating NUL character. 583 */ 584 const GLint len = strlen(shProg->UniformBlocks[i].Name) + 1; 585 586 if (len > max_len) 587 max_len = len; 588 } 589 590 *params = max_len; 591 return; 592 } 593 case GL_ACTIVE_UNIFORM_BLOCKS: 594 if (!has_ubo) 595 break; 596 597 *params = shProg->NumUniformBlocks; 598 return; 599 default: 600 break; 601 } 602 603 _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname=%s)", 604 _mesa_lookup_enum_by_nr(pname)); 605 } 606 607 608 /** 609 * glGetShaderiv() - get GLSL shader state 610 */ 611 static void 612 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params) 613 { 614 struct gl_shader *shader = 615 _mesa_lookup_shader_err(ctx, name, "glGetShaderiv"); 616 617 if (!shader) { 618 return; 619 } 620 621 switch (pname) { 622 case GL_SHADER_TYPE: 623 *params = shader->Type; 624 break; 625 case GL_DELETE_STATUS: 626 *params = shader->DeletePending; 627 break; 628 case GL_COMPILE_STATUS: 629 *params = shader->CompileStatus; 630 break; 631 case GL_INFO_LOG_LENGTH: 632 *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0; 633 break; 634 case GL_SHADER_SOURCE_LENGTH: 635 *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0; 636 break; 637 default: 638 _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)"); 639 return; 640 } 641 } 642 643 644 static void 645 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize, 646 GLsizei *length, GLchar *infoLog) 647 { 648 struct gl_shader_program *shProg 649 = _mesa_lookup_shader_program(ctx, program); 650 if (!shProg) { 651 _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)"); 652 return; 653 } 654 _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog); 655 } 656 657 658 static void 659 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize, 660 GLsizei *length, GLchar *infoLog) 661 { 662 struct gl_shader *sh = _mesa_lookup_shader(ctx, shader); 663 if (!sh) { 664 _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)"); 665 return; 666 } 667 _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog); 668 } 669 670 671 /** 672 * Return shader source code. 673 */ 674 static void 675 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength, 676 GLsizei *length, GLchar *sourceOut) 677 { 678 struct gl_shader *sh; 679 sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource"); 680 if (!sh) { 681 return; 682 } 683 _mesa_copy_string(sourceOut, maxLength, length, sh->Source); 684 } 685 686 687 /** 688 * Set/replace shader source code. A helper function used by 689 * glShaderSource[ARB] and glCreateShaderProgramEXT. 690 */ 691 static void 692 shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source) 693 { 694 struct gl_shader *sh; 695 696 sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource"); 697 if (!sh) 698 return; 699 700 /* free old shader source string and install new one */ 701 if (sh->Source) { 702 free((void *) sh->Source); 703 } 704 sh->Source = source; 705 sh->CompileStatus = GL_FALSE; 706 #ifdef DEBUG 707 sh->SourceChecksum = _mesa_str_checksum(sh->Source); 708 #endif 709 } 710 711 712 /** 713 * Compile a shader. 714 */ 715 static void 716 compile_shader(struct gl_context *ctx, GLuint shaderObj) 717 { 718 struct gl_shader *sh; 719 struct gl_shader_compiler_options *options; 720 721 sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader"); 722 if (!sh) 723 return; 724 725 options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)]; 726 727 /* set default pragma state for shader */ 728 sh->Pragmas = options->DefaultPragmas; 729 730 /* this call will set the sh->CompileStatus field to indicate if 731 * compilation was successful. 732 */ 733 _mesa_glsl_compile_shader(ctx, sh); 734 735 if (sh->CompileStatus == GL_FALSE && 736 (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) { 737 _mesa_debug(ctx, "Error compiling shader %u:\n%s\n", 738 sh->Name, sh->InfoLog); 739 } 740 } 741 742 743 /** 744 * Link a program's shaders. 745 */ 746 static void 747 link_program(struct gl_context *ctx, GLuint program) 748 { 749 struct gl_shader_program *shProg; 750 struct gl_transform_feedback_object *obj = 751 ctx->TransformFeedback.CurrentObject; 752 753 shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram"); 754 if (!shProg) 755 return; 756 757 if (obj->Active 758 && (shProg == ctx->Shader.CurrentVertexProgram 759 || shProg == ctx->Shader.CurrentGeometryProgram 760 || shProg == ctx->Shader.CurrentFragmentProgram)) { 761 _mesa_error(ctx, GL_INVALID_OPERATION, 762 "glLinkProgram(transform feedback active)"); 763 return; 764 } 765 766 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 767 768 _mesa_glsl_link_shader(ctx, shProg); 769 770 if (shProg->LinkStatus == GL_FALSE && 771 (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) { 772 _mesa_debug(ctx, "Error linking program %u:\n%s\n", 773 shProg->Name, shProg->InfoLog); 774 } 775 776 /* debug code */ 777 if (0) { 778 GLuint i; 779 780 printf("Link %u shaders in program %u: %s\n", 781 shProg->NumShaders, shProg->Name, 782 shProg->LinkStatus ? "Success" : "Failed"); 783 784 for (i = 0; i < shProg->NumShaders; i++) { 785 printf(" shader %u, type 0x%x\n", 786 shProg->Shaders[i]->Name, 787 shProg->Shaders[i]->Type); 788 } 789 } 790 } 791 792 793 /** 794 * Print basic shader info (for debug). 795 */ 796 static void 797 print_shader_info(const struct gl_shader_program *shProg) 798 { 799 GLuint i; 800 801 printf("Mesa: glUseProgram(%u)\n", shProg->Name); 802 for (i = 0; i < shProg->NumShaders; i++) { 803 const char *s; 804 switch (shProg->Shaders[i]->Type) { 805 case GL_VERTEX_SHADER: 806 s = "vertex"; 807 break; 808 case GL_FRAGMENT_SHADER: 809 s = "fragment"; 810 break; 811 case GL_GEOMETRY_SHADER: 812 s = "geometry"; 813 break; 814 default: 815 s = ""; 816 } 817 printf(" %s shader %u, checksum %u\n", s, 818 shProg->Shaders[i]->Name, 819 shProg->Shaders[i]->SourceChecksum); 820 } 821 if (shProg->_LinkedShaders[MESA_SHADER_VERTEX]) 822 printf(" vert prog %u\n", 823 shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id); 824 if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]) 825 printf(" frag prog %u\n", 826 shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id); 827 if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]) 828 printf(" geom prog %u\n", 829 shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id); 830 } 831 832 833 /** 834 * Use the named shader program for subsequent glUniform calls 835 */ 836 void 837 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg, 838 const char *caller) 839 { 840 if ((shProg != NULL) && !shProg->LinkStatus) { 841 _mesa_error(ctx, GL_INVALID_OPERATION, 842 "%s(program %u not linked)", caller, shProg->Name); 843 return; 844 } 845 846 if (ctx->Shader.ActiveProgram != shProg) { 847 _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg); 848 } 849 } 850 851 /** 852 */ 853 static bool 854 use_shader_program(struct gl_context *ctx, GLenum type, 855 struct gl_shader_program *shProg) 856 { 857 struct gl_shader_program **target; 858 859 switch (type) { 860 #if FEATURE_ARB_vertex_shader 861 case GL_VERTEX_SHADER: 862 target = &ctx->Shader.CurrentVertexProgram; 863 if ((shProg == NULL) 864 || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) { 865 shProg = NULL; 866 } 867 break; 868 #endif 869 #if FEATURE_ARB_geometry_shader4 870 case GL_GEOMETRY_SHADER_ARB: 871 target = &ctx->Shader.CurrentGeometryProgram; 872 if ((shProg == NULL) 873 || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) { 874 shProg = NULL; 875 } 876 break; 877 #endif 878 #if FEATURE_ARB_fragment_shader 879 case GL_FRAGMENT_SHADER: 880 target = &ctx->Shader.CurrentFragmentProgram; 881 if ((shProg == NULL) 882 || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) { 883 shProg = NULL; 884 } 885 break; 886 #endif 887 default: 888 return false; 889 } 890 891 if (*target != shProg) { 892 FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS); 893 894 /* If the shader is also bound as the current rendering shader, unbind 895 * it from that binding point as well. This ensures that the correct 896 * semantics of glDeleteProgram are maintained. 897 */ 898 switch (type) { 899 #if FEATURE_ARB_vertex_shader 900 case GL_VERTEX_SHADER: 901 /* Empty for now. */ 902 break; 903 #endif 904 #if FEATURE_ARB_geometry_shader4 905 case GL_GEOMETRY_SHADER_ARB: 906 /* Empty for now. */ 907 break; 908 #endif 909 #if FEATURE_ARB_fragment_shader 910 case GL_FRAGMENT_SHADER: 911 if (*target == ctx->Shader._CurrentFragmentProgram) { 912 _mesa_reference_shader_program(ctx, 913 &ctx->Shader._CurrentFragmentProgram, 914 NULL); 915 } 916 break; 917 #endif 918 } 919 920 _mesa_reference_shader_program(ctx, target, shProg); 921 return true; 922 } 923 924 return false; 925 } 926 927 /** 928 * Use the named shader program for subsequent rendering. 929 */ 930 void 931 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg) 932 { 933 use_shader_program(ctx, GL_VERTEX_SHADER, shProg); 934 use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg); 935 use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg); 936 _mesa_active_program(ctx, shProg, "glUseProgram"); 937 938 if (ctx->Driver.UseProgram) 939 ctx->Driver.UseProgram(ctx, shProg); 940 } 941 942 943 /** 944 * Do validation of the given shader program. 945 * \param errMsg returns error message if validation fails. 946 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg) 947 */ 948 static GLboolean 949 validate_shader_program(const struct gl_shader_program *shProg, 950 char *errMsg) 951 { 952 if (!shProg->LinkStatus) { 953 return GL_FALSE; 954 } 955 956 /* From the GL spec, a program is invalid if any of these are true: 957 958 any two active samplers in the current program object are of 959 different types, but refer to the same texture image unit, 960 961 any active sampler in the current program object refers to a texture 962 image unit where fixed-function fragment processing accesses a 963 texture target that does not match the sampler type, or 964 965 the sum of the number of active samplers in the program and the 966 number of texture image units enabled for fixed-function fragment 967 processing exceeds the combined limit on the total number of texture 968 image units allowed. 969 */ 970 971 972 /* 973 * Check: any two active samplers in the current program object are of 974 * different types, but refer to the same texture image unit, 975 */ 976 if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100)) 977 return GL_FALSE; 978 979 return GL_TRUE; 980 } 981 982 983 /** 984 * Called via glValidateProgram() 985 */ 986 static void 987 validate_program(struct gl_context *ctx, GLuint program) 988 { 989 struct gl_shader_program *shProg; 990 char errMsg[100] = ""; 991 992 shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram"); 993 if (!shProg) { 994 return; 995 } 996 997 shProg->Validated = validate_shader_program(shProg, errMsg); 998 if (!shProg->Validated) { 999 /* update info log */ 1000 if (shProg->InfoLog) { 1001 ralloc_free(shProg->InfoLog); 1002 } 1003 shProg->InfoLog = ralloc_strdup(shProg, errMsg); 1004 } 1005 } 1006 1007 1008 1009 void GLAPIENTRY 1010 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader) 1011 { 1012 GET_CURRENT_CONTEXT(ctx); 1013 attach_shader(ctx, program, shader); 1014 } 1015 1016 1017 void GLAPIENTRY 1018 _mesa_AttachShader(GLuint program, GLuint shader) 1019 { 1020 GET_CURRENT_CONTEXT(ctx); 1021 attach_shader(ctx, program, shader); 1022 } 1023 1024 1025 void GLAPIENTRY 1026 _mesa_CompileShaderARB(GLhandleARB shaderObj) 1027 { 1028 GET_CURRENT_CONTEXT(ctx); 1029 if (MESA_VERBOSE & VERBOSE_API) 1030 _mesa_debug(ctx, "glCompileShader %u\n", shaderObj); 1031 compile_shader(ctx, shaderObj); 1032 } 1033 1034 1035 GLuint GLAPIENTRY 1036 _mesa_CreateShader(GLenum type) 1037 { 1038 GET_CURRENT_CONTEXT(ctx); 1039 if (MESA_VERBOSE & VERBOSE_API) 1040 _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type)); 1041 return create_shader(ctx, type); 1042 } 1043 1044 1045 GLhandleARB GLAPIENTRY 1046 _mesa_CreateShaderObjectARB(GLenum type) 1047 { 1048 GET_CURRENT_CONTEXT(ctx); 1049 return create_shader(ctx, type); 1050 } 1051 1052 1053 GLuint GLAPIENTRY 1054 _mesa_CreateProgram(void) 1055 { 1056 GET_CURRENT_CONTEXT(ctx); 1057 if (MESA_VERBOSE & VERBOSE_API) 1058 _mesa_debug(ctx, "glCreateProgram\n"); 1059 return create_shader_program(ctx); 1060 } 1061 1062 1063 GLhandleARB GLAPIENTRY 1064 _mesa_CreateProgramObjectARB(void) 1065 { 1066 GET_CURRENT_CONTEXT(ctx); 1067 return create_shader_program(ctx); 1068 } 1069 1070 1071 void GLAPIENTRY 1072 _mesa_DeleteObjectARB(GLhandleARB obj) 1073 { 1074 if (MESA_VERBOSE & VERBOSE_API) { 1075 GET_CURRENT_CONTEXT(ctx); 1076 _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj); 1077 } 1078 1079 if (obj) { 1080 GET_CURRENT_CONTEXT(ctx); 1081 FLUSH_VERTICES(ctx, 0); 1082 if (is_program(ctx, obj)) { 1083 delete_shader_program(ctx, obj); 1084 } 1085 else if (is_shader(ctx, obj)) { 1086 delete_shader(ctx, obj); 1087 } 1088 else { 1089 /* error? */ 1090 } 1091 } 1092 } 1093 1094 1095 void GLAPIENTRY 1096 _mesa_DeleteProgram(GLuint name) 1097 { 1098 if (name) { 1099 GET_CURRENT_CONTEXT(ctx); 1100 FLUSH_VERTICES(ctx, 0); 1101 delete_shader_program(ctx, name); 1102 } 1103 } 1104 1105 1106 void GLAPIENTRY 1107 _mesa_DeleteShader(GLuint name) 1108 { 1109 if (name) { 1110 GET_CURRENT_CONTEXT(ctx); 1111 FLUSH_VERTICES(ctx, 0); 1112 delete_shader(ctx, name); 1113 } 1114 } 1115 1116 1117 void GLAPIENTRY 1118 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader) 1119 { 1120 GET_CURRENT_CONTEXT(ctx); 1121 detach_shader(ctx, program, shader); 1122 } 1123 1124 1125 void GLAPIENTRY 1126 _mesa_DetachShader(GLuint program, GLuint shader) 1127 { 1128 GET_CURRENT_CONTEXT(ctx); 1129 detach_shader(ctx, program, shader); 1130 } 1131 1132 1133 void GLAPIENTRY 1134 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount, 1135 GLsizei * count, GLhandleARB * obj) 1136 { 1137 GET_CURRENT_CONTEXT(ctx); 1138 get_attached_shaders(ctx, container, maxCount, count, obj); 1139 } 1140 1141 1142 void GLAPIENTRY 1143 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount, 1144 GLsizei *count, GLuint *obj) 1145 { 1146 GET_CURRENT_CONTEXT(ctx); 1147 get_attached_shaders(ctx, program, maxCount, count, obj); 1148 } 1149 1150 1151 void GLAPIENTRY 1152 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length, 1153 GLcharARB * infoLog) 1154 { 1155 GET_CURRENT_CONTEXT(ctx); 1156 if (is_program(ctx, object)) { 1157 get_program_info_log(ctx, object, maxLength, length, infoLog); 1158 } 1159 else if (is_shader(ctx, object)) { 1160 get_shader_info_log(ctx, object, maxLength, length, infoLog); 1161 } 1162 else { 1163 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB"); 1164 } 1165 } 1166 1167 1168 void GLAPIENTRY 1169 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params) 1170 { 1171 GET_CURRENT_CONTEXT(ctx); 1172 /* Implement in terms of GetProgramiv, GetShaderiv */ 1173 if (is_program(ctx, object)) { 1174 if (pname == GL_OBJECT_TYPE_ARB) { 1175 *params = GL_PROGRAM_OBJECT_ARB; 1176 } 1177 else { 1178 get_programiv(ctx, object, pname, params); 1179 } 1180 } 1181 else if (is_shader(ctx, object)) { 1182 if (pname == GL_OBJECT_TYPE_ARB) { 1183 *params = GL_SHADER_OBJECT_ARB; 1184 } 1185 else { 1186 get_shaderiv(ctx, object, pname, params); 1187 } 1188 } 1189 else { 1190 _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB"); 1191 } 1192 } 1193 1194 1195 void GLAPIENTRY 1196 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname, 1197 GLfloat *params) 1198 { 1199 GLint iparams[1]; /* XXX is one element enough? */ 1200 _mesa_GetObjectParameterivARB(object, pname, iparams); 1201 params[0] = (GLfloat) iparams[0]; 1202 } 1203 1204 1205 void GLAPIENTRY 1206 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params) 1207 { 1208 GET_CURRENT_CONTEXT(ctx); 1209 get_programiv(ctx, program, pname, params); 1210 } 1211 1212 1213 void GLAPIENTRY 1214 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params) 1215 { 1216 GET_CURRENT_CONTEXT(ctx); 1217 get_shaderiv(ctx, shader, pname, params); 1218 } 1219 1220 1221 void GLAPIENTRY 1222 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize, 1223 GLsizei *length, GLchar *infoLog) 1224 { 1225 GET_CURRENT_CONTEXT(ctx); 1226 get_program_info_log(ctx, program, bufSize, length, infoLog); 1227 } 1228 1229 1230 void GLAPIENTRY 1231 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize, 1232 GLsizei *length, GLchar *infoLog) 1233 { 1234 GET_CURRENT_CONTEXT(ctx); 1235 get_shader_info_log(ctx, shader, bufSize, length, infoLog); 1236 } 1237 1238 1239 void GLAPIENTRY 1240 _mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength, 1241 GLsizei *length, GLcharARB *sourceOut) 1242 { 1243 GET_CURRENT_CONTEXT(ctx); 1244 get_shader_source(ctx, shader, maxLength, length, sourceOut); 1245 } 1246 1247 1248 GLhandleARB GLAPIENTRY 1249 _mesa_GetHandleARB(GLenum pname) 1250 { 1251 GET_CURRENT_CONTEXT(ctx); 1252 return get_handle(ctx, pname); 1253 } 1254 1255 1256 GLboolean GLAPIENTRY 1257 _mesa_IsProgram(GLuint name) 1258 { 1259 GET_CURRENT_CONTEXT(ctx); 1260 return is_program(ctx, name); 1261 } 1262 1263 1264 GLboolean GLAPIENTRY 1265 _mesa_IsShader(GLuint name) 1266 { 1267 GET_CURRENT_CONTEXT(ctx); 1268 return is_shader(ctx, name); 1269 } 1270 1271 1272 void GLAPIENTRY 1273 _mesa_LinkProgramARB(GLhandleARB programObj) 1274 { 1275 GET_CURRENT_CONTEXT(ctx); 1276 link_program(ctx, programObj); 1277 } 1278 1279 1280 1281 /** 1282 * Read shader source code from a file. 1283 * Useful for debugging to override an app's shader. 1284 */ 1285 static GLcharARB * 1286 read_shader(const char *fname) 1287 { 1288 const int max = 50*1000; 1289 FILE *f = fopen(fname, "r"); 1290 GLcharARB *buffer, *shader; 1291 int len; 1292 1293 if (!f) { 1294 return NULL; 1295 } 1296 1297 buffer = (char *) malloc(max); 1298 len = fread(buffer, 1, max, f); 1299 buffer[len] = 0; 1300 1301 fclose(f); 1302 1303 shader = _mesa_strdup(buffer); 1304 free(buffer); 1305 1306 return shader; 1307 } 1308 1309 1310 /** 1311 * Called via glShaderSource() and glShaderSourceARB() API functions. 1312 * Basically, concatenate the source code strings into one long string 1313 * and pass it to _mesa_shader_source(). 1314 */ 1315 void GLAPIENTRY 1316 _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, 1317 const GLcharARB ** string, const GLint * length) 1318 { 1319 GET_CURRENT_CONTEXT(ctx); 1320 GLint *offsets; 1321 GLsizei i, totalLength; 1322 GLcharARB *source; 1323 GLuint checksum; 1324 1325 if (!shaderObj || string == NULL) { 1326 _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB"); 1327 return; 1328 } 1329 1330 /* 1331 * This array holds offsets of where the appropriate string ends, thus the 1332 * last element will be set to the total length of the source code. 1333 */ 1334 offsets = (GLint *) malloc(count * sizeof(GLint)); 1335 if (offsets == NULL) { 1336 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB"); 1337 return; 1338 } 1339 1340 for (i = 0; i < count; i++) { 1341 if (string[i] == NULL) { 1342 free((GLvoid *) offsets); 1343 _mesa_error(ctx, GL_INVALID_OPERATION, 1344 "glShaderSourceARB(null string)"); 1345 return; 1346 } 1347 if (length == NULL || length[i] < 0) 1348 offsets[i] = strlen(string[i]); 1349 else 1350 offsets[i] = length[i]; 1351 /* accumulate string lengths */ 1352 if (i > 0) 1353 offsets[i] += offsets[i - 1]; 1354 } 1355 1356 /* Total length of source string is sum off all strings plus two. 1357 * One extra byte for terminating zero, another extra byte to silence 1358 * valgrind warnings in the parser/grammer code. 1359 */ 1360 totalLength = offsets[count - 1] + 2; 1361 source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB)); 1362 if (source == NULL) { 1363 free((GLvoid *) offsets); 1364 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB"); 1365 return; 1366 } 1367 1368 for (i = 0; i < count; i++) { 1369 GLint start = (i > 0) ? offsets[i - 1] : 0; 1370 memcpy(source + start, string[i], 1371 (offsets[i] - start) * sizeof(GLcharARB)); 1372 } 1373 source[totalLength - 1] = '\0'; 1374 source[totalLength - 2] = '\0'; 1375 1376 if (SHADER_SUBST) { 1377 /* Compute the shader's source code checksum then try to open a file 1378 * named newshader_<CHECKSUM>. If it exists, use it in place of the 1379 * original shader source code. For debugging. 1380 */ 1381 char filename[100]; 1382 GLcharARB *newSource; 1383 1384 checksum = _mesa_str_checksum(source); 1385 1386 _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum); 1387 1388 newSource = read_shader(filename); 1389 if (newSource) { 1390 fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n", 1391 shaderObj, checksum, filename); 1392 free(source); 1393 source = newSource; 1394 } 1395 } 1396 1397 shader_source(ctx, shaderObj, source); 1398 1399 if (SHADER_SUBST) { 1400 struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj); 1401 if (sh) 1402 sh->SourceChecksum = checksum; /* save original checksum */ 1403 } 1404 1405 free(offsets); 1406 } 1407 1408 1409 void GLAPIENTRY 1410 _mesa_UseProgramObjectARB(GLhandleARB program) 1411 { 1412 GET_CURRENT_CONTEXT(ctx); 1413 struct gl_shader_program *shProg; 1414 struct gl_transform_feedback_object *obj = 1415 ctx->TransformFeedback.CurrentObject; 1416 1417 ASSERT_OUTSIDE_BEGIN_END(ctx); 1418 1419 if (obj->Active && !obj->Paused) { 1420 _mesa_error(ctx, GL_INVALID_OPERATION, 1421 "glUseProgram(transform feedback active)"); 1422 return; 1423 } 1424 1425 if (program) { 1426 shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram"); 1427 if (!shProg) { 1428 return; 1429 } 1430 if (!shProg->LinkStatus) { 1431 _mesa_error(ctx, GL_INVALID_OPERATION, 1432 "glUseProgram(program %u not linked)", program); 1433 return; 1434 } 1435 1436 /* debug code */ 1437 if (ctx->Shader.Flags & GLSL_USE_PROG) { 1438 print_shader_info(shProg); 1439 } 1440 } 1441 else { 1442 shProg = NULL; 1443 } 1444 1445 _mesa_use_program(ctx, shProg); 1446 } 1447 1448 1449 void GLAPIENTRY 1450 _mesa_ValidateProgramARB(GLhandleARB program) 1451 { 1452 GET_CURRENT_CONTEXT(ctx); 1453 validate_program(ctx, program); 1454 } 1455 1456 #ifdef FEATURE_ES2 1457 1458 void GLAPIENTRY 1459 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, 1460 GLint* range, GLint* precision) 1461 { 1462 const struct gl_program_constants *limits; 1463 const struct gl_precision *p; 1464 GET_CURRENT_CONTEXT(ctx); 1465 1466 switch (shadertype) { 1467 case GL_VERTEX_SHADER: 1468 limits = &ctx->Const.VertexProgram; 1469 break; 1470 case GL_FRAGMENT_SHADER: 1471 limits = &ctx->Const.FragmentProgram; 1472 break; 1473 default: 1474 _mesa_error(ctx, GL_INVALID_ENUM, 1475 "glGetShaderPrecisionFormat(shadertype)"); 1476 return; 1477 } 1478 1479 switch (precisiontype) { 1480 case GL_LOW_FLOAT: 1481 p = &limits->LowFloat; 1482 break; 1483 case GL_MEDIUM_FLOAT: 1484 p = &limits->MediumFloat; 1485 break; 1486 case GL_HIGH_FLOAT: 1487 p = &limits->HighFloat; 1488 break; 1489 case GL_LOW_INT: 1490 p = &limits->LowInt; 1491 break; 1492 case GL_MEDIUM_INT: 1493 p = &limits->MediumInt; 1494 break; 1495 case GL_HIGH_INT: 1496 p = &limits->HighInt; 1497 break; 1498 default: 1499 _mesa_error(ctx, GL_INVALID_ENUM, 1500 "glGetShaderPrecisionFormat(precisiontype)"); 1501 return; 1502 } 1503 1504 range[0] = p->RangeMin; 1505 range[1] = p->RangeMax; 1506 precision[0] = p->Precision; 1507 } 1508 1509 1510 void GLAPIENTRY 1511 _mesa_ReleaseShaderCompiler(void) 1512 { 1513 _mesa_destroy_shader_compiler_caches(); 1514 } 1515 1516 1517 void GLAPIENTRY 1518 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, 1519 const void* binary, GLint length) 1520 { 1521 GET_CURRENT_CONTEXT(ctx); 1522 (void) n; 1523 (void) shaders; 1524 (void) binaryformat; 1525 (void) binary; 1526 (void) length; 1527 _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__); 1528 } 1529 1530 #endif /* FEATURE_ES2 */ 1531 1532 1533 #if FEATURE_ARB_geometry_shader4 1534 1535 void GLAPIENTRY 1536 _mesa_ProgramParameteriARB(GLuint program, GLenum pname, GLint value) 1537 { 1538 struct gl_shader_program *shProg; 1539 GET_CURRENT_CONTEXT(ctx); 1540 1541 ASSERT_OUTSIDE_BEGIN_END(ctx); 1542 1543 shProg = _mesa_lookup_shader_program_err(ctx, program, 1544 "glProgramParameteri"); 1545 if (!shProg) 1546 return; 1547 1548 switch (pname) { 1549 case GL_GEOMETRY_VERTICES_OUT_ARB: 1550 if (value < 1 || 1551 (unsigned) value > ctx->Const.MaxGeometryOutputVertices) { 1552 _mesa_error(ctx, GL_INVALID_VALUE, 1553 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d", 1554 value); 1555 return; 1556 } 1557 shProg->Geom.VerticesOut = value; 1558 break; 1559 case GL_GEOMETRY_INPUT_TYPE_ARB: 1560 switch (value) { 1561 case GL_POINTS: 1562 case GL_LINES: 1563 case GL_LINES_ADJACENCY_ARB: 1564 case GL_TRIANGLES: 1565 case GL_TRIANGLES_ADJACENCY_ARB: 1566 shProg->Geom.InputType = value; 1567 break; 1568 default: 1569 _mesa_error(ctx, GL_INVALID_VALUE, 1570 "glProgramParameteri(geometry input type = %s", 1571 _mesa_lookup_enum_by_nr(value)); 1572 return; 1573 } 1574 break; 1575 case GL_GEOMETRY_OUTPUT_TYPE_ARB: 1576 switch (value) { 1577 case GL_POINTS: 1578 case GL_LINE_STRIP: 1579 case GL_TRIANGLE_STRIP: 1580 shProg->Geom.OutputType = value; 1581 break; 1582 default: 1583 _mesa_error(ctx, GL_INVALID_VALUE, 1584 "glProgramParameteri(geometry output type = %s", 1585 _mesa_lookup_enum_by_nr(value)); 1586 return; 1587 } 1588 break; 1589 default: 1590 _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)", 1591 _mesa_lookup_enum_by_nr(pname)); 1592 break; 1593 } 1594 } 1595 1596 #endif 1597 1598 void 1599 _mesa_use_shader_program(struct gl_context *ctx, GLenum type, 1600 struct gl_shader_program *shProg) 1601 { 1602 use_shader_program(ctx, type, shProg); 1603 1604 if (ctx->Driver.UseProgram) 1605 ctx->Driver.UseProgram(ctx, shProg); 1606 } 1607 1608 1609 /** 1610 * For GL_EXT_separate_shader_objects 1611 */ 1612 void GLAPIENTRY 1613 _mesa_UseShaderProgramEXT(GLenum type, GLuint program) 1614 { 1615 GET_CURRENT_CONTEXT(ctx); 1616 struct gl_shader_program *shProg = NULL; 1617 1618 ASSERT_OUTSIDE_BEGIN_END(ctx); 1619 1620 if (!validate_shader_target(ctx, type)) { 1621 _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)"); 1622 return; 1623 } 1624 1625 if (ctx->TransformFeedback.CurrentObject->Active && 1626 !ctx->TransformFeedback.CurrentObject->Paused) { 1627 _mesa_error(ctx, GL_INVALID_OPERATION, 1628 "glUseShaderProgramEXT(transform feedback is active)"); 1629 return; 1630 } 1631 1632 if (program) { 1633 shProg = _mesa_lookup_shader_program_err(ctx, program, 1634 "glUseShaderProgramEXT"); 1635 if (shProg == NULL) 1636 return; 1637 1638 if (!shProg->LinkStatus) { 1639 _mesa_error(ctx, GL_INVALID_OPERATION, 1640 "glUseShaderProgramEXT(program not linked)"); 1641 return; 1642 } 1643 } 1644 1645 _mesa_use_shader_program(ctx, type, shProg); 1646 } 1647 1648 1649 /** 1650 * For GL_EXT_separate_shader_objects 1651 */ 1652 void GLAPIENTRY 1653 _mesa_ActiveProgramEXT(GLuint program) 1654 { 1655 GET_CURRENT_CONTEXT(ctx); 1656 struct gl_shader_program *shProg = (program != 0) 1657 ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT") 1658 : NULL; 1659 1660 _mesa_active_program(ctx, shProg, "glActiveProgramEXT"); 1661 return; 1662 } 1663 1664 1665 /** 1666 * For GL_EXT_separate_shader_objects 1667 */ 1668 GLuint GLAPIENTRY 1669 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string) 1670 { 1671 GET_CURRENT_CONTEXT(ctx); 1672 const GLuint shader = create_shader(ctx, type); 1673 GLuint program = 0; 1674 1675 if (shader) { 1676 shader_source(ctx, shader, _mesa_strdup(string)); 1677 compile_shader(ctx, shader); 1678 1679 program = create_shader_program(ctx); 1680 if (program) { 1681 struct gl_shader_program *shProg; 1682 struct gl_shader *sh; 1683 GLint compiled = GL_FALSE; 1684 1685 shProg = _mesa_lookup_shader_program(ctx, program); 1686 sh = _mesa_lookup_shader(ctx, shader); 1687 1688 get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled); 1689 if (compiled) { 1690 attach_shader(ctx, program, shader); 1691 link_program(ctx, program); 1692 detach_shader(ctx, program, shader); 1693 1694 #if 0 1695 /* Possibly... */ 1696 if (active-user-defined-varyings-in-linked-program) { 1697 append-error-to-info-log; 1698 shProg->LinkStatus = GL_FALSE; 1699 } 1700 #endif 1701 } 1702 1703 ralloc_strcat(&shProg->InfoLog, sh->InfoLog); 1704 } 1705 1706 delete_shader(ctx, shader); 1707 } 1708 1709 return program; 1710 } 1711 1712 /** 1713 * Plug in shader-related functions into API dispatch table. 1714 */ 1715 void 1716 _mesa_init_shader_dispatch(const struct gl_context *ctx, 1717 struct _glapi_table *exec) 1718 { 1719 #if FEATURE_GL 1720 /* GL_ARB_vertex/fragment_shader */ 1721 if (ctx->API != API_OPENGLES2) { 1722 SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB); 1723 SET_GetHandleARB(exec, _mesa_GetHandleARB); 1724 SET_DetachObjectARB(exec, _mesa_DetachObjectARB); 1725 SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB); 1726 SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB); 1727 SET_AttachObjectARB(exec, _mesa_AttachObjectARB); 1728 SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB); 1729 SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB); 1730 SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB); 1731 SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB); 1732 } 1733 1734 SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB); 1735 SET_CompileShaderARB(exec, _mesa_CompileShaderARB); 1736 SET_LinkProgramARB(exec, _mesa_LinkProgramARB); 1737 SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB); 1738 SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB); 1739 SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB); 1740 1741 /* OpenGL 2.0 */ 1742 SET_AttachShader(exec, _mesa_AttachShader); 1743 SET_CreateProgram(exec, _mesa_CreateProgram); 1744 SET_CreateShader(exec, _mesa_CreateShader); 1745 SET_DeleteProgram(exec, _mesa_DeleteProgram); 1746 SET_DeleteShader(exec, _mesa_DeleteShader); 1747 SET_DetachShader(exec, _mesa_DetachShader); 1748 SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders); 1749 SET_GetProgramiv(exec, _mesa_GetProgramiv); 1750 SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog); 1751 SET_GetShaderiv(exec, _mesa_GetShaderiv); 1752 SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog); 1753 SET_IsProgram(exec, _mesa_IsProgram); 1754 SET_IsShader(exec, _mesa_IsShader); 1755 1756 #if FEATURE_ARB_vertex_shader 1757 SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB); 1758 SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB); 1759 SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB); 1760 #endif 1761 1762 if (ctx->API != API_OPENGLES2) { 1763 #if FEATURE_ARB_geometry_shader4 1764 SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB); 1765 #endif 1766 1767 SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT); 1768 SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT); 1769 SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT); 1770 } 1771 1772 /* GL_EXT_gpu_shader4 / GL 3.0 */ 1773 if (ctx->API != API_OPENGLES2) { 1774 SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation); 1775 } 1776 if (ctx->API != API_OPENGLES2 || _mesa_is_gles3(ctx)) { 1777 SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation); 1778 } 1779 1780 /* GL_ARB_ES2_compatibility */ 1781 SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler); 1782 SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat); 1783 1784 /* GL_ARB_blend_func_extended */ 1785 if (ctx->API != API_OPENGLES2) { 1786 SET_BindFragDataLocationIndexed(exec, _mesa_BindFragDataLocationIndexed); 1787 SET_GetFragDataIndex(exec, _mesa_GetFragDataIndex); 1788 } 1789 #endif /* FEATURE_GL */ 1790 } 1791 1792
