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