src/mesa/main/texenvprogram.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "glheader.h"
  29 #include "macros.h"
  30 #include "enums.h"
  31 #include "shader/prog_parameter.h"
  32 #include "shader/prog_cache.h"
  33 #include "shader/prog_instruction.h"
  34 #include "shader/prog_print.h"
  35 #include "shader/prog_statevars.h"
  36 #include "shader/programopt.h"
  37 #include "texenvprogram.h"
  38
  39 /**
  40  * Up to nine instructions per tex unit, plus fog, specular color.
  41  */
  42 #define MAX_INSTRUCTIONS ((MAX_TEXTURE_UNITS * 9) + 12)
  43
  44 #define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)
  45
  46 struct mode_opt {
  47    GLubyte Source:4;
  48    GLubyte Operand:3;
  49 };
  50
  51 struct state_key {
  52    GLuint nr_enabled_units:8;
  53    GLuint enabled_units:8;
  54    GLuint separate_specular:1;
  55    GLuint fog_enabled:1;
  56    GLuint fog_mode:2;
  57    GLuint inputs_available:12;
  58
  59    struct {
  60       GLuint enabled:1;
  61       GLuint source_index:3;   /* one of TEXTURE_1D/2D/3D/CUBE/RECT_INDEX */
  62       GLuint ScaleShiftRGB:2;
  63       GLuint ScaleShiftA:2;
  64
  65       GLuint NumArgsRGB:2;
  66       GLuint ModeRGB:4;
  67       GLuint NumArgsA:2;
  68       GLuint ModeA:4;
  69
  70       struct mode_opt OptRGB[3];
  71       struct mode_opt OptA[3];
  72    } unit[8];
  73 };
  74
  75 #define FOG_LINEAR  0
  76 #define FOG_EXP     1
  77 #define FOG_EXP2    2
  78 #define FOG_UNKNOWN 3
  79
  80 static GLuint translate_fog_mode( GLenum mode )
  81 {
  82    switch (mode) {
  83    case GL_LINEAR: return FOG_LINEAR;
  84    case GL_EXP: return FOG_EXP;
  85    case GL_EXP2: return FOG_EXP2;
  86    default: return FOG_UNKNOWN;
  87    }
  88 }
  89
  90 #define OPR_SRC_COLOR           0
  91 #define OPR_ONE_MINUS_SRC_COLOR 1
  92 #define OPR_SRC_ALPHA           2
  93 #define OPR_ONE_MINUS_SRC_ALPHA 3
  94 #define OPR_ZERO                4
  95 #define OPR_ONE                 5
  96 #define OPR_UNKNOWN             7
  97
  98 static GLuint translate_operand( GLenum operand )
  99 {
 100    switch (operand) {
 101    case GL_SRC_COLOR: return OPR_SRC_COLOR;
 102    case GL_ONE_MINUS_SRC_COLOR: return OPR_ONE_MINUS_SRC_COLOR;
 103    case GL_SRC_ALPHA: return OPR_SRC_ALPHA;
 104    case GL_ONE_MINUS_SRC_ALPHA: return OPR_ONE_MINUS_SRC_ALPHA;
 105    case GL_ZERO: return OPR_ZERO;
 106    case GL_ONE: return OPR_ONE;
 107    default:     return OPR_UNKNOWN;
 108    }
 109 }
 110
 111 #define SRC_TEXTURE  0
 112 #define SRC_TEXTURE0 1
 113 #define SRC_TEXTURE1 2
 114 #define SRC_TEXTURE2 3
 115 #define SRC_TEXTURE3 4
 116 #define SRC_TEXTURE4 5
 117 #define SRC_TEXTURE5 6
 118 #define SRC_TEXTURE6 7
 119 #define SRC_TEXTURE7 8
 120 #define SRC_CONSTANT 9
 121 #define SRC_PRIMARY_COLOR 10
 122 #define SRC_PREVIOUS 11
 123 #define SRC_UNKNOWN  15
 124
 125 static GLuint translate_source( GLenum src )
 126 {
 127    switch (src) {
 128    case GL_TEXTURE: return SRC_TEXTURE;
 129    case GL_TEXTURE0:
 130    case GL_TEXTURE1:
 131    case GL_TEXTURE2:
 132    case GL_TEXTURE3:
 133    case GL_TEXTURE4:
 134    case GL_TEXTURE5:
 135    case GL_TEXTURE6:
 136    case GL_TEXTURE7: return SRC_TEXTURE0 + (src - GL_TEXTURE0);
 137    case GL_CONSTANT: return SRC_CONSTANT;
 138    case GL_PRIMARY_COLOR: return SRC_PRIMARY_COLOR;
 139    case GL_PREVIOUS: return SRC_PREVIOUS;
 140    default: return SRC_UNKNOWN;
 141    }
 142 }
 143
 144 #define MODE_REPLACE       0
 145 #define MODE_MODULATE      1
 146 #define MODE_ADD           2
 147 #define MODE_ADD_SIGNED    3
 148 #define MODE_INTERPOLATE   4
 149 #define MODE_SUBTRACT      5
 150 #define MODE_DOT3_RGB      6
 151 #define MODE_DOT3_RGB_EXT  7
 152 #define MODE_DOT3_RGBA     8
 153 #define MODE_DOT3_RGBA_EXT 9
 154 #define MODE_MODULATE_ADD_ATI           10
 155 #define MODE_MODULATE_SIGNED_ADD_ATI    11
 156 #define MODE_MODULATE_SUBTRACT_ATI      12
 157 #define MODE_UNKNOWN       15
 158
 159 static GLuint translate_mode( GLenum mode )
 160 {
 161    switch (mode) {
 162    case GL_REPLACE: return MODE_REPLACE;
 163    case GL_MODULATE: return MODE_MODULATE;
 164    case GL_ADD: return MODE_ADD;
 165    case GL_ADD_SIGNED: return MODE_ADD_SIGNED;
 166    case GL_INTERPOLATE: return MODE_INTERPOLATE;
 167    case GL_SUBTRACT: return MODE_SUBTRACT;
 168    case GL_DOT3_RGB: return MODE_DOT3_RGB;
 169    case GL_DOT3_RGB_EXT: return MODE_DOT3_RGB_EXT;
 170    case GL_DOT3_RGBA: return MODE_DOT3_RGBA;
 171    case GL_DOT3_RGBA_EXT: return MODE_DOT3_RGBA_EXT;
 172    case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI;
 173    case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI;
 174    case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI;
 175    default: return MODE_UNKNOWN;
 176    }
 177 }
 178
 179 #define TEXTURE_UNKNOWN_INDEX 7
 180 static GLuint translate_tex_src_bit( GLbitfield bit )
 181 {
 182    switch (bit) {
 183    case TEXTURE_1D_BIT:   return TEXTURE_1D_INDEX;
 184    case TEXTURE_2D_BIT:   return TEXTURE_2D_INDEX;
 185    case TEXTURE_RECT_BIT: return TEXTURE_RECT_INDEX;
 186    case TEXTURE_3D_BIT:   return TEXTURE_3D_INDEX;
 187    case TEXTURE_CUBE_BIT: return TEXTURE_CUBE_INDEX;
 188    default: return TEXTURE_UNKNOWN_INDEX;
 189    }
 190 }
 191
 192 #define VERT_BIT_TEX_ANY    (0xff << VERT_ATTRIB_TEX0)
 193 #define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0)
 194
 195 /**
 196  * Identify all possible varying inputs.  The fragment program will
 197  * never reference non-varying inputs, but will track them via state
 198  * constants instead.
 199  *
 200  * This function figures out all the inputs that the fragment program
 201  * has access to.  The bitmask is later reduced to just those which
 202  * are actually referenced.
 203  */
 204 static GLbitfield get_fp_input_mask( GLcontext *ctx )
 205 {
 206    GLbitfield fp_inputs = 0x0;
 207
 208    if (ctx->VertexProgram._Overriden) {
 209       /* Somebody's messing with the vertex program and we don't have
 210        * a clue what's happening.  Assume that it could be producing
 211        * all possible outputs.
 212        */
 213       fp_inputs = ~0;
 214    }
 215    else if (ctx->RenderMode == GL_FEEDBACK) {
 216       fp_inputs = (FRAG_BIT_COL0 | FRAG_BIT_TEX0);
 217    }
 218    else if (!ctx->VertexProgram._Enabled ||
 219             !ctx->VertexProgram._Current) {
 220
 221       /* Fixed function logic */
 222       GLbitfield varying_inputs = ctx->varying_vp_inputs;
 223
 224       /* These get generated in the setup routine regardless of the
 225        * vertex program:
 226        */
 227       if (ctx->Point.PointSprite)
 228          varying_inputs |= FRAG_BITS_TEX_ANY;
 229
 230       /* First look at what values may be computed by the generated
 231        * vertex program:
 232        */
 233       if (ctx->Light.Enabled) {
 234          fp_inputs |= FRAG_BIT_COL0;
 235
 236          if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
 237             fp_inputs |= FRAG_BIT_COL1;
 238       }
 239
 240       fp_inputs |= (ctx->Texture._TexGenEnabled |
 241                     ctx->Texture._TexMatEnabled) << FRAG_ATTRIB_TEX0;
 242
 243       /* Then look at what might be varying as a result of enabled
 244        * arrays, etc:
 245        */
 246       if (varying_inputs & VERT_BIT_COLOR0) fp_inputs |= FRAG_BIT_COL0;
 247       if (varying_inputs & VERT_BIT_COLOR1) fp_inputs |= FRAG_BIT_COL1;
 248
 249       fp_inputs |= (((varying_inputs & VERT_BIT_TEX_ANY) >> VERT_ATTRIB_TEX0)
 250                     << FRAG_ATTRIB_TEX0);
 251
 252    }
 253    else {
 254       /* calculate from vp->outputs */
 255       GLbitfield vp_outputs = ctx->VertexProgram._Current->Base.OutputsWritten;
 256
 257       /* These get generated in the setup routine regardless of the
 258        * vertex program:
 259        */
 260       if (ctx->Point.PointSprite)
 261          vp_outputs |= FRAG_BITS_TEX_ANY;
 262
 263       if (vp_outputs & (1 << VERT_RESULT_COL0)) fp_inputs |= FRAG_BIT_COL0;
 264       if (vp_outputs & (1 << VERT_RESULT_COL1)) fp_inputs |= FRAG_BIT_COL1;
 265
 266       fp_inputs |= (((vp_outputs & VERT_RESULT_TEX_ANY) >> VERT_RESULT_TEX0)
 267                     << FRAG_ATTRIB_TEX0);
 268    }
 269
 270    return fp_inputs;
 271 }
 272
 273
 274 /**
 275  * Examine current texture environment state and generate a unique
 276  * key to identify it.
 277  */
 278 static void make_state_key( GLcontext *ctx,  struct state_key *key )
 279 {
 280    GLuint i, j;
 281    GLbitfield inputs_referenced = FRAG_BIT_COL0;
 282    GLbitfield inputs_available = get_fp_input_mask( ctx );
 283
 284    memset(key, 0, sizeof(*key));
 285
 286    for (i=0;i<MAX_TEXTURE_UNITS;i++) {
 287       const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
 288
 289       if (!texUnit->_ReallyEnabled)
 290          continue;
 291
 292       key->unit[i].enabled = 1;
 293       key->enabled_units |= (1<<i);
 294       key->nr_enabled_units = i+1;
 295       inputs_referenced |= FRAG_BIT_TEX(i);
 296
 297       key->unit[i].source_index =
 298          translate_tex_src_bit(texUnit->_ReallyEnabled);
 299
 300       key->unit[i].NumArgsRGB = texUnit->_CurrentCombine->_NumArgsRGB;
 301       key->unit[i].NumArgsA = texUnit->_CurrentCombine->_NumArgsA;
 302
 303       key->unit[i].ModeRGB =
 304          translate_mode(texUnit->_CurrentCombine->ModeRGB);
 305       key->unit[i].ModeA =
 306          translate_mode(texUnit->_CurrentCombine->ModeA);
 307
 308       key->unit[i].ScaleShiftRGB = texUnit->_CurrentCombine->ScaleShiftRGB;
 309       key->unit[i].ScaleShiftA = texUnit->_CurrentCombine->ScaleShiftA;
 310
 311       for (j=0;j<3;j++) {
 312          key->unit[i].OptRGB[j].Operand =
 313             translate_operand(texUnit->_CurrentCombine->OperandRGB[j]);
 314          key->unit[i].OptA[j].Operand =
 315             translate_operand(texUnit->_CurrentCombine->OperandA[j]);
 316          key->unit[i].OptRGB[j].Source =
 317             translate_source(texUnit->_CurrentCombine->SourceRGB[j]);
 318          key->unit[i].OptA[j].Source =
 319             translate_source(texUnit->_CurrentCombine->SourceA[j]);
 320       }
 321    }
 322
 323    if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
 324       key->separate_specular = 1;
 325       inputs_referenced |= FRAG_BIT_COL1;
 326    }
 327
 328    if (ctx->Fog.Enabled) {
 329       key->fog_enabled = 1;
 330       key->fog_mode = translate_fog_mode(ctx->Fog.Mode);
 331       inputs_referenced |= FRAG_BIT_FOGC; /* maybe */
 332    }
 333
 334    key->inputs_available = (inputs_available & inputs_referenced);
 335 }
 336
 337 /**
 338  * Use uregs to represent registers internally, translate to Mesa's
 339  * expected formats on emit.
 340  *
 341  * NOTE: These are passed by value extensively in this file rather
 342  * than as usual by pointer reference.  If this disturbs you, try
 343  * remembering they are just 32bits in size.
 344  *
 345  * GCC is smart enough to deal with these dword-sized structures in
 346  * much the same way as if I had defined them as dwords and was using
 347  * macros to access and set the fields.  This is much nicer and easier
 348  * to evolve.
 349  */
 350 struct ureg {
 351    GLuint file:4;
 352    GLuint idx:8;
 353    GLuint negatebase:1;
 354    GLuint abs:1;
 355    GLuint negateabs:1;
 356    GLuint swz:12;
 357    GLuint pad:5;
 358 };
 359
 360 static const struct ureg undef = {
 361    PROGRAM_UNDEFINED,
 362    ~0,
 363    0,
 364    0,
 365    0,
 366    0,
 367    0
 368 };
 369
 370
 371 /** State used to build the fragment program:
 372  */
 373 struct texenv_fragment_program {
 374    struct gl_fragment_program *program;
 375    GLcontext *ctx;
 376    struct state_key *state;
 377
 378    GLbitfield alu_temps;        /**< Track texture indirections, see spec. */
 379    GLbitfield temps_output;     /**< Track texture indirections, see spec. */
 380    GLbitfield temp_in_use;      /**< Tracks temporary regs which are in use. */
 381    GLboolean error;
 382
 383    struct ureg src_texture[MAX_TEXTURE_UNITS];
 384    /* Reg containing each texture unit's sampled texture color,
 385     * else undef.
 386     */
 387
 388    struct ureg src_previous;    /**< Reg containing color from previous
 389                                  * stage.  May need to be decl'd.
 390                                  */
 391
 392    GLuint last_tex_stage;       /**< Number of last enabled texture unit */
 393
 394    struct ureg half;
 395    struct ureg one;
 396    struct ureg zero;
 397 };
 398
 399
 400
 401 static struct ureg make_ureg(GLuint file, GLuint idx)
 402 {
 403    struct ureg reg;
 404    reg.file = file;
 405    reg.idx = idx;
 406    reg.negatebase = 0;
 407    reg.abs = 0;
 408    reg.negateabs = 0;
 409    reg.swz = SWIZZLE_NOOP;
 410    reg.pad = 0;
 411    return reg;
 412 }
 413
 414 static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
 415 {
 416    reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
 417                            GET_SWZ(reg.swz, y),
 418                            GET_SWZ(reg.swz, z),
 419                            GET_SWZ(reg.swz, w));
 420
 421    return reg;
 422 }
 423
 424 static struct ureg swizzle1( struct ureg reg, int x )
 425 {
 426    return swizzle(reg, x, x, x, x);
 427 }
 428
 429 static struct ureg negate( struct ureg reg )
 430 {
 431    reg.negatebase ^= 1;
 432    return reg;
 433 }
 434
 435 static GLboolean is_undef( struct ureg reg )
 436 {
 437    return reg.file == PROGRAM_UNDEFINED;
 438 }
 439
 440
 441 static struct ureg get_temp( struct texenv_fragment_program *p )
 442 {
 443    GLint bit;
 444
 445    /* First try and reuse temps which have been used already:
 446     */
 447    bit = _mesa_ffs( ~p->temp_in_use & p->alu_temps );
 448
 449    /* Then any unused temporary:
 450     */
 451    if (!bit)
 452       bit = _mesa_ffs( ~p->temp_in_use );
 453
 454    if (!bit) {
 455       _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
 456       _mesa_exit(1);
 457    }
 458
 459    if ((GLuint) bit > p->program->Base.NumTemporaries)
 460       p->program->Base.NumTemporaries = bit;
 461
 462    p->temp_in_use |= 1<<(bit-1);
 463    return make_ureg(PROGRAM_TEMPORARY, (bit-1));
 464 }
 465
 466 static struct ureg get_tex_temp( struct texenv_fragment_program *p )
 467 {
 468    int bit;
 469
 470    /* First try to find available temp not previously used (to avoid
 471     * starting a new texture indirection).  According to the spec, the
 472     * ~p->temps_output isn't necessary, but will keep it there for
 473     * now:
 474     */
 475    bit = _mesa_ffs( ~p->temp_in_use & ~p->alu_temps & ~p->temps_output );
 476
 477    /* Then any unused temporary:
 478     */
 479    if (!bit)
 480       bit = _mesa_ffs( ~p->temp_in_use );
 481
 482    if (!bit) {
 483       _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
 484       _mesa_exit(1);
 485    }
 486
 487    if ((GLuint) bit > p->program->Base.NumTemporaries)
 488       p->program->Base.NumTemporaries = bit;
 489
 490    p->temp_in_use |= 1<<(bit-1);
 491    return make_ureg(PROGRAM_TEMPORARY, (bit-1));
 492 }
 493
 494
 495 /** Mark a temp reg as being no longer allocatable. */
 496 static void reserve_temp( struct texenv_fragment_program *p, struct ureg r )
 497 {
 498    if (r.file == PROGRAM_TEMPORARY)
 499       p->temps_output |= (1 << r.idx);
 500 }
 501
 502
 503 static void release_temps(GLcontext *ctx, struct texenv_fragment_program *p )
 504 {
 505    GLuint max_temp = ctx->Const.FragmentProgram.MaxTemps;
 506
 507    /* KW: To support tex_env_crossbar, don't release the registers in
 508     * temps_output.
 509     */
 510    if (max_temp >= sizeof(int) * 8)
 511       p->temp_in_use = p->temps_output;
 512    else
 513       p->temp_in_use = ~((1<<max_temp)-1) | p->temps_output;
 514 }
 515
 516
 517 static struct ureg register_param5( struct texenv_fragment_program *p,
 518                                     GLint s0,
 519                                     GLint s1,
 520                                     GLint s2,
 521                                     GLint s3,
 522                                     GLint s4)
 523 {
 524    gl_state_index tokens[STATE_LENGTH];
 525    GLuint idx;
 526    tokens[0] = s0;
 527    tokens[1] = s1;
 528    tokens[2] = s2;
 529    tokens[3] = s3;
 530    tokens[4] = s4;
 531    idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );
 532    return make_ureg(PROGRAM_STATE_VAR, idx);
 533 }
 534
 535
 536 #define register_param1(p,s0)          register_param5(p,s0,0,0,0,0)
 537 #define register_param2(p,s0,s1)       register_param5(p,s0,s1,0,0,0)
 538 #define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)
 539 #define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
 540
 541 static GLuint frag_to_vert_attrib( GLuint attrib )
 542 {
 543    switch (attrib) {
 544    case FRAG_ATTRIB_COL0: return VERT_ATTRIB_COLOR0;
 545    case FRAG_ATTRIB_COL1: return VERT_ATTRIB_COLOR1;
 546    default:
 547       assert(attrib >= FRAG_ATTRIB_TEX0);
 548       assert(attrib <= FRAG_ATTRIB_TEX7);
 549       return attrib - FRAG_ATTRIB_TEX0 + VERT_ATTRIB_TEX0;
 550    }
 551 }
 552
 553
 554 static struct ureg register_input( struct texenv_fragment_program *p, GLuint input )
 555 {
 556    if (p->state->inputs_available & (1<<input)) {
 557       p->program->Base.InputsRead |= (1 << input);
 558       return make_ureg(PROGRAM_INPUT, input);
 559    }
 560    else {
 561       GLuint idx = frag_to_vert_attrib( input );
 562       return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB, idx );
 563    }
 564 }
 565
 566
 567 static void emit_arg( struct prog_src_register *reg,
 568                       struct ureg ureg )
 569 {
 570    reg->File = ureg.file;
 571    reg->Index = ureg.idx;
 572    reg->Swizzle = ureg.swz;
 573    reg->NegateBase = ureg.negatebase ? 0xf : 0x0;
 574    reg->Abs = ureg.abs;
 575    reg->NegateAbs = ureg.negateabs;
 576 }
 577
 578 static void emit_dst( struct prog_dst_register *dst,
 579                       struct ureg ureg, GLuint mask )
 580 {
 581    dst->File = ureg.file;
 582    dst->Index = ureg.idx;
 583    dst->WriteMask = mask;
 584    dst->CondMask = COND_TR;  /* always pass cond test */
 585    dst->CondSwizzle = SWIZZLE_NOOP;
 586 }
 587
 588 static struct prog_instruction *
 589 emit_op(struct texenv_fragment_program *p,
 590         enum prog_opcode op,
 591         struct ureg dest,
 592         GLuint mask,
 593         GLboolean saturate,
 594         struct ureg src0,
 595         struct ureg src1,
 596         struct ureg src2 )
 597 {
 598    GLuint nr = p->program->Base.NumInstructions++;
 599    struct prog_instruction *inst = &p->program->Base.Instructions[nr];
 600
 601    assert(nr < MAX_INSTRUCTIONS);
 602
 603    _mesa_init_instructions(inst, 1);
 604    inst->Opcode = op;
 605
 606    emit_arg( &inst->SrcReg[0], src0 );
 607    emit_arg( &inst->SrcReg[1], src1 );
 608    emit_arg( &inst->SrcReg[2], src2 );
 609
 610    inst->SaturateMode = saturate ? SATURATE_ZERO_ONE : SATURATE_OFF;
 611
 612    emit_dst( &inst->DstReg, dest, mask );
 613
 614 #if 0
 615    /* Accounting for indirection tracking:
 616     */
 617    if (dest.file == PROGRAM_TEMPORARY)
 618       p->temps_output |= 1 << dest.idx;
 619 #endif
 620
 621    return inst;
 622 }
 623
 624
 625 static struct ureg emit_arith( struct texenv_fragment_program *p,
 626                                enum prog_opcode op,
 627                                struct ureg dest,
 628                                GLuint mask,
 629                                GLboolean saturate,
 630                                struct ureg src0,
 631                                struct ureg src1,
 632                                struct ureg src2 )
 633 {
 634    emit_op(p, op, dest, mask, saturate, src0, src1, src2);
 635
 636    /* Accounting for indirection tracking:
 637     */
 638    if (src0.file == PROGRAM_TEMPORARY)
 639       p->alu_temps |= 1 << src0.idx;
 640
 641    if (!is_undef(src1) && src1.file == PROGRAM_TEMPORARY)
 642       p->alu_temps |= 1 << src1.idx;
 643
 644    if (!is_undef(src2) && src2.file == PROGRAM_TEMPORARY)
 645       p->alu_temps |= 1 << src2.idx;
 646
 647    if (dest.file == PROGRAM_TEMPORARY)
 648       p->alu_temps |= 1 << dest.idx;
 649
 650    p->program->Base.NumAluInstructions++;
 651    return dest;
 652 }
 653
 654 static struct ureg emit_texld( struct texenv_fragment_program *p,
 655                                enum prog_opcode op,
 656                                struct ureg dest,
 657                                GLuint destmask,
 658                                GLuint tex_unit,
 659                                GLuint tex_idx,
 660                                struct ureg coord )
 661 {
 662    struct prog_instruction *inst = emit_op( p, op,
 663                                           dest, destmask,
 664                                           GL_FALSE,     /* don't saturate? */
 665                                           coord,        /* arg 0? */
 666                                           undef,
 667                                           undef);
 668
 669    inst->TexSrcTarget = tex_idx;
 670    inst->TexSrcUnit = tex_unit;
 671
 672    p->program->Base.NumTexInstructions++;
 673
 674    /* Accounting for indirection tracking:
 675     */
 676    reserve_temp(p, dest);
 677
 678    /* Is this a texture indirection?
 679     */
 680    if ((coord.file == PROGRAM_TEMPORARY &&
 681         (p->temps_output & (1<<coord.idx))) ||
 682        (dest.file == PROGRAM_TEMPORARY &&
 683         (p->alu_temps & (1<<dest.idx)))) {
 684       p->program->Base.NumTexIndirections++;
 685       p->temps_output = 1<<coord.idx;
 686       p->alu_temps = 0;
 687       assert(0);                /* KW: texture env crossbar */
 688    }
 689
 690    return dest;
 691 }
 692
 693
 694 static struct ureg register_const4f( struct texenv_fragment_program *p,
 695                                      GLfloat s0,
 696                                      GLfloat s1,
 697                                      GLfloat s2,
 698                                      GLfloat s3)
 699 {
 700    GLfloat values[4];
 701    GLuint idx, swizzle;
 702    struct ureg r;
 703    values[0] = s0;
 704    values[1] = s1;
 705    values[2] = s2;
 706    values[3] = s3;
 707    idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,
 708                                      &swizzle );
 709    r = make_ureg(PROGRAM_CONSTANT, idx);
 710    r.swz = swizzle;
 711    return r;
 712 }
 713
 714 #define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)
 715 #define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)
 716 #define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)
 717 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
 718
 719
 720 static struct ureg get_one( struct texenv_fragment_program *p )
 721 {
 722    if (is_undef(p->one))
 723       p->one = register_scalar_const(p, 1.0);
 724    return p->one;
 725 }
 726
 727 static struct ureg get_half( struct texenv_fragment_program *p )
 728 {
 729    if (is_undef(p->half))
 730       p->half = register_scalar_const(p, 0.5);
 731    return p->half;
 732 }
 733
 734 static struct ureg get_zero( struct texenv_fragment_program *p )
 735 {
 736    if (is_undef(p->zero))
 737       p->zero = register_scalar_const(p, 0.0);
 738    return p->zero;
 739 }
 740
 741
 742 static void program_error( struct texenv_fragment_program *p, const char *msg )
 743 {
 744    _mesa_problem(NULL, msg);
 745    p->error = 1;
 746 }
 747
 748 static struct ureg get_source( struct texenv_fragment_program *p,
 749                                GLuint src, GLuint unit )
 750 {
 751    switch (src) {
 752    case SRC_TEXTURE:
 753       assert(!is_undef(p->src_texture[unit]));
 754       return p->src_texture[unit];
 755
 756    case SRC_TEXTURE0:
 757    case SRC_TEXTURE1:
 758    case SRC_TEXTURE2:
 759    case SRC_TEXTURE3:
 760    case SRC_TEXTURE4:
 761    case SRC_TEXTURE5:
 762    case SRC_TEXTURE6:
 763    case SRC_TEXTURE7:
 764       assert(!is_undef(p->src_texture[src - SRC_TEXTURE0]));
 765       return p->src_texture[src - SRC_TEXTURE0];
 766
 767    case SRC_CONSTANT:
 768       return register_param2(p, STATE_TEXENV_COLOR, unit);
 769
 770    case SRC_PRIMARY_COLOR:
 771       return register_input(p, FRAG_ATTRIB_COL0);
 772
 773    case SRC_PREVIOUS:
 774    default:
 775       if (is_undef(p->src_previous))
 776          return register_input(p, FRAG_ATTRIB_COL0);
 777       else
 778          return p->src_previous;
 779    }
 780 }
 781
 782 static struct ureg emit_combine_source( struct texenv_fragment_program *p,
 783                                         GLuint mask,
 784                                         GLuint unit,
 785                                         GLuint source,
 786                                         GLuint operand )
 787 {
 788    struct ureg arg, src, one;
 789
 790    src = get_source(p, source, unit);
 791
 792    switch (operand) {
 793    case OPR_ONE_MINUS_SRC_COLOR:
 794       /* Get unused tmp,
 795        * Emit tmp = 1.0 - arg.xyzw
 796        */
 797       arg = get_temp( p );
 798       one = get_one( p );
 799       return emit_arith( p, OPCODE_SUB, arg, mask, 0, one, src, undef);
 800
 801    case OPR_SRC_ALPHA:
 802       if (mask == WRITEMASK_W)
 803          return src;
 804       else
 805          return swizzle1( src, SWIZZLE_W );
 806    case OPR_ONE_MINUS_SRC_ALPHA:
 807       /* Get unused tmp,
 808        * Emit tmp = 1.0 - arg.wwww
 809        */
 810       arg = get_temp(p);
 811       one = get_one(p);
 812       return emit_arith(p, OPCODE_SUB, arg, mask, 0,
 813                         one, swizzle1(src, SWIZZLE_W), undef);
 814    case OPR_ZERO:
 815       return get_zero(p);
 816    case OPR_ONE:
 817       return get_one(p);
 818    case OPR_SRC_COLOR:
 819    default:
 820       return src;
 821    }
 822 }
 823
 824 static GLboolean args_match( struct state_key *key, GLuint unit )
 825 {
 826    GLuint i, nr = key->unit[unit].NumArgsRGB;
 827
 828    for (i = 0 ; i < nr ; i++) {
 829       if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source)
 830          return GL_FALSE;
 831
 832       switch(key->unit[unit].OptA[i].Operand) {
 833       case OPR_SRC_ALPHA:
 834          switch(key->unit[unit].OptRGB[i].Operand) {
 835          case OPR_SRC_COLOR:
 836          case OPR_SRC_ALPHA:
 837             break;
 838          default:
 839             return GL_FALSE;
 840          }
 841          break;
 842       case OPR_ONE_MINUS_SRC_ALPHA:
 843          switch(key->unit[unit].OptRGB[i].Operand) {
 844          case OPR_ONE_MINUS_SRC_COLOR:
 845          case OPR_ONE_MINUS_SRC_ALPHA:
 846             break;
 847          default:
 848             return GL_FALSE;
 849          }
 850          break;
 851       default:
 852          return GL_FALSE;       /* impossible */
 853       }
 854    }
 855
 856    return GL_TRUE;
 857 }
 858
 859 static struct ureg emit_combine( struct texenv_fragment_program *p,
 860                                  struct ureg dest,
 861                                  GLuint mask,
 862                                  GLboolean saturate,
 863                                  GLuint unit,
 864                                  GLuint nr,
 865                                  GLuint mode,
 866                                  const struct mode_opt *opt)
 867 {
 868    struct ureg src[3];
 869    struct ureg tmp, half;
 870    GLuint i;
 871
 872    tmp = undef; /* silence warning (bug 5318) */
 873
 874    for (i = 0; i < nr; i++)
 875       src[i] = emit_combine_source( p, mask, unit, opt[i].Source, opt[i].Operand );
 876
 877    switch (mode) {
 878    case MODE_REPLACE:
 879       if (mask == WRITEMASK_XYZW && !saturate)
 880          return src[0];
 881       else
 882          return emit_arith( p, OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );
 883    case MODE_MODULATE:
 884       return emit_arith( p, OPCODE_MUL, dest, mask, saturate,
 885                          src[0], src[1], undef );
 886    case MODE_ADD:
 887       return emit_arith( p, OPCODE_ADD, dest, mask, saturate,
 888                          src[0], src[1], undef );
 889    case MODE_ADD_SIGNED:
 890       /* tmp = arg0 + arg1
 891        * result = tmp - .5
 892        */
 893       half = get_half(p);
 894       tmp = get_temp( p );
 895       emit_arith( p, OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );
 896       emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp, half, undef );
 897       return dest;
 898    case MODE_INTERPOLATE:
 899       /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:
 900        */
 901       return emit_arith( p, OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );
 902
 903    case MODE_SUBTRACT:
 904       return emit_arith( p, OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );
 905
 906    case MODE_DOT3_RGBA:
 907    case MODE_DOT3_RGBA_EXT:
 908    case MODE_DOT3_RGB_EXT:
 909    case MODE_DOT3_RGB: {
 910       struct ureg tmp0 = get_temp( p );
 911       struct ureg tmp1 = get_temp( p );
 912       struct ureg neg1 = register_scalar_const(p, -1);
 913       struct ureg two  = register_scalar_const(p, 2);
 914
 915       /* tmp0 = 2*src0 - 1
 916        * tmp1 = 2*src1 - 1
 917        *
 918        * dst = tmp0 dot3 tmp1
 919        */
 920       emit_arith( p, OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0,
 921                   two, src[0], neg1);
 922
 923       if (_mesa_memcmp(&src[0], &src[1], sizeof(struct ureg)) == 0)
 924          tmp1 = tmp0;
 925       else
 926          emit_arith( p, OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0,
 927                      two, src[1], neg1);
 928       emit_arith( p, OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);
 929       return dest;
 930    }
 931    case MODE_MODULATE_ADD_ATI:
 932       /* Arg0 * Arg2 + Arg1 */
 933       return emit_arith( p, OPCODE_MAD, dest, mask, saturate,
 934                          src[0], src[2], src[1] );
 935    case MODE_MODULATE_SIGNED_ADD_ATI: {
 936       /* Arg0 * Arg2 + Arg1 - 0.5 */
 937       struct ureg tmp0 = get_temp(p);
 938       half = get_half(p);
 939       emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );
 940       emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
 941       return dest;
 942    }
 943    case MODE_MODULATE_SUBTRACT_ATI:
 944       /* Arg0 * Arg2 - Arg1 */
 945       emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );
 946       return dest;
 947    default:
 948       return src[0];
 949    }
 950 }
 951
 952
 953 /**
 954  * Generate instructions for one texture unit's env/combiner mode.
 955  */
 956 static struct ureg
 957 emit_texenv(struct texenv_fragment_program *p, GLuint unit)
 958 {
 959    struct state_key *key = p->state;
 960    GLboolean saturate = (unit < p->last_tex_stage);
 961    GLuint rgb_shift, alpha_shift;
 962    struct ureg out, shift;
 963    struct ureg dest;
 964
 965    if (!key->unit[unit].enabled) {
 966       return get_source(p, SRC_PREVIOUS, 0);
 967    }
 968
 969    switch (key->unit[unit].ModeRGB) {
 970    case MODE_DOT3_RGB_EXT:
 971       alpha_shift = key->unit[unit].ScaleShiftA;
 972       rgb_shift = 0;
 973       break;
 974    case MODE_DOT3_RGBA_EXT:
 975       alpha_shift = 0;
 976       rgb_shift = 0;
 977       break;
 978    default:
 979       rgb_shift = key->unit[unit].ScaleShiftRGB;
 980       alpha_shift = key->unit[unit].ScaleShiftA;
 981       break;
 982    }
 983
 984    /* If this is the very last calculation, emit direct to output reg:
 985     */
 986    if (key->separate_specular ||
 987        unit != p->last_tex_stage ||
 988        alpha_shift ||
 989        rgb_shift)
 990       dest = get_temp( p );
 991    else
 992       dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLR);
 993
 994    /* Emit the RGB and A combine ops
 995     */
 996    if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&
 997        args_match(key, unit)) {
 998       out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
 999                           unit,
1000                           key->unit[unit].NumArgsRGB,
1001                           key->unit[unit].ModeRGB,
1002                           key->unit[unit].OptRGB);
1003    }
1004    else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
1005             key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {
1006
1007       out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
1008                           unit,
1009                           key->unit[unit].NumArgsRGB,
1010                           key->unit[unit].ModeRGB,
1011                           key->unit[unit].OptRGB);
1012    }
1013    else {
1014       /* Need to do something to stop from re-emitting identical
1015        * argument calculations here:
1016        */
1017       out = emit_combine( p, dest, WRITEMASK_XYZ, saturate,
1018                           unit,
1019                           key->unit[unit].NumArgsRGB,
1020                           key->unit[unit].ModeRGB,
1021                           key->unit[unit].OptRGB);
1022       out = emit_combine( p, dest, WRITEMASK_W, saturate,
1023                           unit,
1024                           key->unit[unit].NumArgsA,
1025                           key->unit[unit].ModeA,
1026                           key->unit[unit].OptA);
1027    }
1028
1029    /* Deal with the final shift:
1030     */
1031    if (alpha_shift || rgb_shift) {
1032       if (rgb_shift == alpha_shift) {
1033          shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));
1034       }
1035       else {
1036          shift = register_const4f(p,
1037                                   (GLfloat)(1<<rgb_shift),
1038                                   (GLfloat)(1<<rgb_shift),
1039                                   (GLfloat)(1<<rgb_shift),
1040                                   (GLfloat)(1<<alpha_shift));
1041       }
1042       return emit_arith( p, OPCODE_MUL, dest, WRITEMASK_XYZW,
1043                          saturate, out, shift, undef );
1044    }
1045    else
1046       return out;
1047 }
1048
1049
1050 /**
1051  * Generate instruction for getting a texture source term.
1052  */
1053 static void load_texture( struct texenv_fragment_program *p, GLuint unit )
1054 {
1055    if (is_undef(p->src_texture[unit])) {
1056       GLuint dim = p->state->unit[unit].source_index;
1057       struct ureg texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);
1058       struct ureg tmp = get_tex_temp( p );
1059
1060       if (dim == TEXTURE_UNKNOWN_INDEX)
1061          program_error(p, "TexSrcBit");
1062
1063       /* TODO: Use D0_MASK_XY where possible.
1064        */
1065       if (p->state->unit[unit].enabled) {
1066          p->src_texture[unit] = emit_texld( p, OPCODE_TXP,
1067                                             tmp, WRITEMASK_XYZW,
1068                                             unit, dim, texcoord );
1069          p->program->Base.SamplersUsed |= (1 << unit);
1070          /* This identity mapping should already be in place
1071           * (see _mesa_init_program_struct()) but let's be safe.
1072           */
1073          p->program->Base.SamplerUnits[unit] = unit;
1074       }
1075       else
1076          p->src_texture[unit] = get_zero(p);
1077    }
1078 }
1079
1080 static GLboolean load_texenv_source( struct texenv_fragment_program *p,
1081                                      GLuint src, GLuint unit )
1082 {
1083    switch (src) {
1084    case SRC_TEXTURE:
1085       load_texture(p, unit);
1086       break;
1087
1088    case SRC_TEXTURE0:
1089    case SRC_TEXTURE1:
1090    case SRC_TEXTURE2:
1091    case SRC_TEXTURE3:
1092    case SRC_TEXTURE4:
1093    case SRC_TEXTURE5:
1094    case SRC_TEXTURE6:
1095    case SRC_TEXTURE7:
1096       load_texture(p, src - SRC_TEXTURE0);
1097       break;
1098
1099    default:
1100       break;
1101    }
1102
1103    return GL_TRUE;
1104 }
1105
1106
1107 /**
1108  * Generate instructions for loading all texture source terms.
1109  */
1110 static GLboolean
1111 load_texunit_sources( struct texenv_fragment_program *p, int unit )
1112 {
1113    struct state_key *key = p->state;
1114    GLuint i;
1115
1116    for (i = 0; i < key->unit[unit].NumArgsRGB; i++) {
1117       load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit);
1118    }
1119
1120    for (i = 0; i < key->unit[unit].NumArgsA; i++) {
1121       load_texenv_source( p, key->unit[unit].OptA[i].Source, unit );
1122    }
1123
1124    return GL_TRUE;
1125 }
1126
1127
1128 /**
1129  * Generate a new fragment program which implements the context's
1130  * current texture env/combine mode.
1131  */
1132 static void
1133 create_new_program(GLcontext *ctx, struct state_key *key,
1134                    struct gl_fragment_program *program)
1135 {
1136    struct prog_instruction instBuffer[MAX_INSTRUCTIONS];
1137    struct texenv_fragment_program p;
1138    GLuint unit;
1139    struct ureg cf, out;
1140
1141    _mesa_memset(&p, 0, sizeof(p));
1142    p.ctx = ctx;
1143    p.state = key;
1144    p.program = program;
1145
1146    /* During code generation, use locally-allocated instruction buffer,
1147     * then alloc dynamic storage below.
1148     */
1149    p.program->Base.Instructions = instBuffer;
1150    p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;
1151    p.program->Base.NumTexIndirections = 1;      /* correct? */
1152    p.program->Base.NumTexInstructions = 0;
1153    p.program->Base.NumAluInstructions = 0;
1154    p.program->Base.String = NULL;
1155    p.program->Base.NumInstructions =
1156    p.program->Base.NumTemporaries =
1157    p.program->Base.NumParameters =
1158    p.program->Base.NumAttributes = p.program->Base.NumAddressRegs = 0;
1159    p.program->Base.Parameters = _mesa_new_parameter_list();
1160
1161    p.program->Base.InputsRead = 0;
1162    p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLR;
1163
1164    for (unit = 0; unit < MAX_TEXTURE_UNITS; unit++)
1165       p.src_texture[unit] = undef;
1166
1167    p.src_previous = undef;
1168    p.half = undef;
1169    p.zero = undef;
1170    p.one = undef;
1171
1172    p.last_tex_stage = 0;
1173    release_temps(ctx, &p);
1174
1175    if (key->enabled_units) {
1176       /* First pass - to support texture_env_crossbar, first identify
1177        * all referenced texture sources and emit texld instructions
1178        * for each:
1179        */
1180       for (unit = 0 ; unit < ctx->Const.MaxTextureUnits ; unit++)
1181          if (key->unit[unit].enabled) {
1182             load_texunit_sources( &p, unit );
1183             p.last_tex_stage = unit;
1184          }
1185
1186       /* Second pass - emit combine instructions to build final color:
1187        */
1188       for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++)
1189          if (key->enabled_units & (1<<unit)) {
1190             p.src_previous = emit_texenv( &p, unit );
1191             reserve_temp(&p, p.src_previous); /* don't re-use this temp reg */
1192             release_temps(ctx, &p);     /* release all temps */
1193          }
1194    }
1195
1196    cf = get_source( &p, SRC_PREVIOUS, 0 );
1197    out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLR );
1198
1199    if (key->separate_specular) {
1200       /* Emit specular add.
1201        */
1202       struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);
1203       emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
1204       emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
1205    }
1206    else if (_mesa_memcmp(&cf, &out, sizeof(cf)) != 0) {
1207       /* Will wind up in here if no texture enabled or a couple of
1208        * other scenarios (GL_REPLACE for instance).
1209        */
1210       emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
1211    }
1212
1213    /* Finish up:
1214     */
1215    emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);
1216
1217    if (key->fog_enabled) {
1218       /* Pull fog mode from GLcontext, the value in the state key is
1219        * a reduced value and not what is expected in FogOption
1220        */
1221       p.program->FogOption = ctx->Fog.Mode;
1222       p.program->Base.InputsRead |= FRAG_BIT_FOGC; /* XXX new */
1223    } else
1224       p.program->FogOption = GL_NONE;
1225
1226    if (p.program->Base.NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections)
1227       program_error(&p, "Exceeded max nr indirect texture lookups");
1228
1229    if (p.program->Base.NumTexInstructions > ctx->Const.FragmentProgram.MaxTexInstructions)
1230       program_error(&p, "Exceeded max TEX instructions");
1231
1232    if (p.program->Base.NumAluInstructions > ctx->Const.FragmentProgram.MaxAluInstructions)
1233       program_error(&p, "Exceeded max ALU instructions");
1234
1235    ASSERT(p.program->Base.NumInstructions <= MAX_INSTRUCTIONS);
1236
1237    /* Allocate final instruction array */
1238    p.program->Base.Instructions
1239       = _mesa_alloc_instructions(p.program->Base.NumInstructions);
1240    if (!p.program->Base.Instructions) {
1241       _mesa_error(ctx, GL_OUT_OF_MEMORY,
1242                   "generating tex env program");
1243       return;
1244    }
1245    _mesa_copy_instructions(p.program->Base.Instructions, instBuffer,
1246                            p.program->Base.NumInstructions);
1247
1248    if (p.program->FogOption) {
1249       _mesa_append_fog_code(ctx, p.program);
1250       p.program->FogOption = GL_NONE;
1251    }
1252
1253
1254    /* Notify driver the fragment program has (actually) changed.
1255     */
1256    if (ctx->Driver.ProgramStringNotify) {
1257       ctx->Driver.ProgramStringNotify( ctx, GL_FRAGMENT_PROGRAM_ARB,
1258                                        &p.program->Base );
1259    }
1260
1261    if (DISASSEM) {
1262       _mesa_print_program(&p.program->Base);
1263       _mesa_printf("\n");
1264    }
1265 }
1266
1267
1268 /**
1269  * Return a fragment program which implements the current
1270  * fixed-function texture, fog and color-sum operations.
1271  */
1272 struct gl_fragment_program *
1273 _mesa_get_fixed_func_fragment_program(GLcontext *ctx)
1274 {
1275    struct gl_fragment_program *prog;
1276    struct state_key key;
1277
1278    make_state_key(ctx, &key);
1279
1280    prog = (struct gl_fragment_program *)
1281       _mesa_search_program_cache(ctx->FragmentProgram.Cache,
1282                                  &key, sizeof(key));
1283
1284    if (!prog) {
1285       prog = (struct gl_fragment_program *)
1286          ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
1287
1288       create_new_program(ctx, &key, prog);
1289
1290       _mesa_program_cache_insert(ctx, ctx->FragmentProgram.Cache,
1291                                  &key, sizeof(key), &prog->Base);
1292    }
1293
1294    return prog;
1295 }
1296
1297
1298
1299 /**
1300  * If _MaintainTexEnvProgram is set we'll generate a fragment program that
1301  * implements the current texture env/combine mode.
1302  * This function generates that program and puts it into effect.
1303  */
1304 void
1305 _mesa_UpdateTexEnvProgram( GLcontext *ctx )
1306 {
1307    const struct gl_fragment_program *prev = ctx->FragmentProgram._Current;
1308
1309    ASSERT(ctx->FragmentProgram._MaintainTexEnvProgram);
1310
1311    /* If a conventional fragment program/shader isn't in effect... */
1312    if (!ctx->FragmentProgram._Enabled &&
1313        (!ctx->Shader.CurrentProgram ||
1314         !ctx->Shader.CurrentProgram->FragmentProgram) ) {
1315
1316       ctx->FragmentProgram._Current
1317          = ctx->FragmentProgram._TexEnvProgram
1318          = _mesa_get_fixed_func_fragment_program(ctx);
1319    }
1320
1321    /* Tell the driver about the change.  Could define a new target for
1322     * this?
1323     */
1324    if (ctx->FragmentProgram._Current != prev && ctx->Driver.BindProgram) {
1325       ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
1326                          (struct gl_program *) ctx->FragmentProgram._Current);
1327    }
1328 }