src/mesa/main/shaderapi.c

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