src/mesa/main/texenvprogram.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 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 "texenvprogram.h"
  32
  33 #include "shader/program.h"
  34 #include "shader/program_instruction.h"
  35
  36 #define MAX_INSTRUCTIONS 100
  37
  38 #define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)
  39
  40 struct mode_opt {
  41    GLuint Source:4;
  42    GLuint Operand:3;
  43 };
  44
  45 struct state_key {
  46    GLbitfield enabled_units;
  47    GLuint separate_specular:1;
  48    GLuint fog_enabled:1;
  49    GLuint fog_mode:2;
  50
  51    struct {
  52       GLuint enabled:1;
  53       GLuint source_index:3;   /* one of TEXTURE_1D/2D/3D/CUBE/RECT_INDEX */
  54       GLuint ScaleShiftRGB:2;
  55       GLuint ScaleShiftA:2;
  56
  57       GLuint NumArgsRGB:2;
  58       GLuint ModeRGB:4;
  59       struct mode_opt OptRGB[3];
  60
  61       GLuint NumArgsA:2;
  62       GLuint ModeA:4;
  63       struct mode_opt OptA[3];
  64    } unit[8];
  65 };
  66
  67 #define FOG_LINEAR  0
  68 #define FOG_EXP     1
  69 #define FOG_EXP2    2
  70 #define FOG_UNKNOWN 3
  71
  72 static GLuint translate_fog_mode( GLenum mode )
  73 {
  74    switch (mode) {
  75    case GL_LINEAR: return FOG_LINEAR;
  76    case GL_EXP: return FOG_EXP;
  77    case GL_EXP2: return FOG_EXP2;
  78    default: return FOG_UNKNOWN;
  79    }
  80 }
  81
  82 #define OPR_SRC_COLOR           0
  83 #define OPR_ONE_MINUS_SRC_COLOR 1
  84 #define OPR_SRC_ALPHA           2
  85 #define OPR_ONE_MINUS_SRC_ALPHA 3
  86 #define OPR_ZERO                4
  87 #define OPR_ONE                 5
  88 #define OPR_UNKNOWN             7
  89
  90 static GLuint translate_operand( GLenum operand )
  91 {
  92    switch (operand) {
  93    case GL_SRC_COLOR: return OPR_SRC_COLOR;
  94    case GL_ONE_MINUS_SRC_COLOR: return OPR_ONE_MINUS_SRC_COLOR;
  95    case GL_SRC_ALPHA: return OPR_SRC_ALPHA;
  96    case GL_ONE_MINUS_SRC_ALPHA: return OPR_ONE_MINUS_SRC_ALPHA;
  97    case GL_ZERO: return OPR_ZERO;
  98    case GL_ONE: return OPR_ONE;
  99    default:     return OPR_UNKNOWN;
 100    }
 101 }
 102
 103 #define SRC_TEXTURE  0
 104 #define SRC_TEXTURE0 1
 105 #define SRC_TEXTURE1 2
 106 #define SRC_TEXTURE2 3
 107 #define SRC_TEXTURE3 4
 108 #define SRC_TEXTURE4 5
 109 #define SRC_TEXTURE5 6
 110 #define SRC_TEXTURE6 7
 111 #define SRC_TEXTURE7 8
 112 #define SRC_CONSTANT 9
 113 #define SRC_PRIMARY_COLOR 10
 114 #define SRC_PREVIOUS 11
 115 #define SRC_UNKNOWN  15
 116
 117 static GLuint translate_source( GLenum src )
 118 {
 119    switch (src) {
 120    case GL_TEXTURE: return SRC_TEXTURE;
 121    case GL_TEXTURE0:
 122    case GL_TEXTURE1:
 123    case GL_TEXTURE2:
 124    case GL_TEXTURE3:
 125    case GL_TEXTURE4:
 126    case GL_TEXTURE5:
 127    case GL_TEXTURE6:
 128    case GL_TEXTURE7: return SRC_TEXTURE0 + (src - GL_TEXTURE0);
 129    case GL_CONSTANT: return SRC_CONSTANT;
 130    case GL_PRIMARY_COLOR: return SRC_PRIMARY_COLOR;
 131    case GL_PREVIOUS: return SRC_PREVIOUS;
 132    default: return SRC_UNKNOWN;
 133    }
 134 }
 135
 136 #define MODE_REPLACE       0
 137 #define MODE_MODULATE      1
 138 #define MODE_ADD           2
 139 #define MODE_ADD_SIGNED    3
 140 #define MODE_INTERPOLATE   4
 141 #define MODE_SUBTRACT      5
 142 #define MODE_DOT3_RGB      6
 143 #define MODE_DOT3_RGB_EXT  7
 144 #define MODE_DOT3_RGBA     8
 145 #define MODE_DOT3_RGBA_EXT 9
 146 #define MODE_MODULATE_ADD_ATI           10
 147 #define MODE_MODULATE_SIGNED_ADD_ATI    11
 148 #define MODE_MODULATE_SUBTRACT_ATI      12
 149 #define MODE_UNKNOWN       15
 150
 151 static GLuint translate_mode( GLenum mode )
 152 {
 153    switch (mode) {
 154    case GL_REPLACE: return MODE_REPLACE;
 155    case GL_MODULATE: return MODE_MODULATE;
 156    case GL_ADD: return MODE_ADD;
 157    case GL_ADD_SIGNED: return MODE_ADD_SIGNED;
 158    case GL_INTERPOLATE: return MODE_INTERPOLATE;
 159    case GL_SUBTRACT: return MODE_SUBTRACT;
 160    case GL_DOT3_RGB: return MODE_DOT3_RGB;
 161    case GL_DOT3_RGB_EXT: return MODE_DOT3_RGB_EXT;
 162    case GL_DOT3_RGBA: return MODE_DOT3_RGBA;
 163    case GL_DOT3_RGBA_EXT: return MODE_DOT3_RGBA_EXT;
 164    case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI;
 165    case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI;
 166    case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI;
 167    default: return MODE_UNKNOWN;
 168    }
 169 }
 170
 171 #define TEXTURE_UNKNOWN_INDEX 7
 172 static GLuint translate_tex_src_bit( GLbitfield bit )
 173 {
 174    switch (bit) {
 175    case TEXTURE_1D_BIT:   return TEXTURE_1D_INDEX;
 176    case TEXTURE_2D_BIT:   return TEXTURE_2D_INDEX;
 177    case TEXTURE_RECT_BIT: return TEXTURE_RECT_INDEX;
 178    case TEXTURE_3D_BIT:   return TEXTURE_3D_INDEX;
 179    case TEXTURE_CUBE_BIT: return TEXTURE_CUBE_INDEX;
 180    default: return TEXTURE_UNKNOWN_INDEX;
 181    }
 182 }
 183
 184 /**
 185  * Examine current texture environment state and generate a unique
 186  * key to identify it.
 187  */
 188 static struct state_key *
 189 make_state_key(GLcontext *ctx)
 190 {
 191    struct state_key *key = CALLOC_STRUCT(state_key);
 192    GLuint i, j;
 193
 194    for (i=0;i<MAX_TEXTURE_UNITS;i++) {
 195       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
 196
 197       if (!texUnit->_ReallyEnabled)
 198          continue;
 199
 200       key->unit[i].enabled = 1;
 201       key->enabled_units |= (1<<i);
 202
 203       key->unit[i].source_index =
 204          translate_tex_src_bit(texUnit->_ReallyEnabled);
 205
 206       key->unit[i].NumArgsRGB = texUnit->_CurrentCombine->_NumArgsRGB;
 207       key->unit[i].NumArgsA = texUnit->_CurrentCombine->_NumArgsA;
 208
 209       key->unit[i].ModeRGB =
 210          translate_mode(texUnit->_CurrentCombine->ModeRGB);
 211       key->unit[i].ModeA =
 212          translate_mode(texUnit->_CurrentCombine->ModeA);
 213
 214       key->unit[i].ScaleShiftRGB = texUnit->_CurrentCombine->ScaleShiftRGB;
 215       key->unit[i].ScaleShiftA = texUnit->_CurrentCombine->ScaleShiftRGB;
 216
 217       for (j=0;j<3;j++) {
 218          key->unit[i].OptRGB[j].Operand =
 219             translate_operand(texUnit->_CurrentCombine->OperandRGB[j]);
 220          key->unit[i].OptA[j].Operand =
 221             translate_operand(texUnit->_CurrentCombine->OperandA[j]);
 222          key->unit[i].OptRGB[j].Source =
 223             translate_source(texUnit->_CurrentCombine->SourceRGB[j]);
 224          key->unit[i].OptA[j].Source =
 225             translate_source(texUnit->_CurrentCombine->SourceA[j]);
 226       }
 227    }
 228
 229    if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
 230       key->separate_specular = 1;
 231
 232    if (ctx->Fog.Enabled) {
 233       key->fog_enabled = 1;
 234       key->fog_mode = translate_fog_mode(ctx->Fog.Mode);
 235    }
 236
 237    return key;
 238 }
 239
 240 /* Use uregs to represent registers internally, translate to Mesa's
 241  * expected formats on emit.
 242  *
 243  * NOTE: These are passed by value extensively in this file rather
 244  * than as usual by pointer reference.  If this disturbs you, try
 245  * remembering they are just 32bits in size.
 246  *
 247  * GCC is smart enough to deal with these dword-sized structures in
 248  * much the same way as if I had defined them as dwords and was using
 249  * macros to access and set the fields.  This is much nicer and easier
 250  * to evolve.
 251  */
 252 struct ureg {
 253    GLuint file:4;
 254    GLuint idx:8;
 255    GLuint negatebase:1;
 256    GLuint abs:1;
 257    GLuint negateabs:1;
 258    GLuint swz:12;
 259    GLuint pad:5;
 260 };
 261
 262 const static struct ureg undef = {
 263    ~0,
 264    ~0,
 265    0,
 266    0,
 267    0,
 268    0,
 269    0
 270 };
 271
 272
 273 /* State used to build the fragment program:
 274  */
 275 struct texenv_fragment_program {
 276    struct fragment_program *program;
 277    GLcontext *ctx;
 278    struct state_key *state;
 279
 280    GLbitfield alu_temps;        /* Track texture indirections, see spec. */
 281    GLbitfield temps_output;     /* Track texture indirections, see spec. */
 282    GLbitfield temp_in_use;      /* Tracks temporary regs which are in use. */
 283    GLboolean error;
 284
 285    struct ureg src_texture[MAX_TEXTURE_UNITS];
 286    /* Reg containing each texture unit's sampled texture color,
 287     * else undef.
 288     */
 289
 290    struct ureg src_previous;    /* Reg containing color from previous
 291                                  * stage.  May need to be decl'd.
 292                                  */
 293
 294    GLuint last_tex_stage;       /* Number of last enabled texture unit */
 295
 296    struct ureg half;
 297    struct ureg one;
 298    struct ureg zero;
 299 };
 300
 301
 302
 303 static struct ureg make_ureg(GLuint file, GLuint idx)
 304 {
 305    struct ureg reg;
 306    reg.file = file;
 307    reg.idx = idx;
 308    reg.negatebase = 0;
 309    reg.abs = 0;
 310    reg.negateabs = 0;
 311    reg.swz = SWIZZLE_NOOP;
 312    reg.pad = 0;
 313    return reg;
 314 }
 315
 316 static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
 317 {
 318    reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
 319                            GET_SWZ(reg.swz, y),
 320                            GET_SWZ(reg.swz, z),
 321                            GET_SWZ(reg.swz, w));
 322
 323    return reg;
 324 }
 325
 326 static struct ureg swizzle1( struct ureg reg, int x )
 327 {
 328    return swizzle(reg, x, x, x, x);
 329 }
 330
 331 static struct ureg negate( struct ureg reg )
 332 {
 333    reg.negatebase ^= 1;
 334    return reg;
 335 }
 336
 337 static GLboolean is_undef( struct ureg reg )
 338 {
 339    return reg.file == 0xf;
 340 }
 341
 342
 343 static struct ureg get_temp( struct texenv_fragment_program *p )
 344 {
 345    int bit;
 346
 347    /* First try and reuse temps which have been used already:
 348     */
 349    bit = _mesa_ffs( ~p->temp_in_use & p->alu_temps );
 350
 351    /* Then any unused temporary:
 352     */
 353    if (!bit)
 354       bit = _mesa_ffs( ~p->temp_in_use );
 355
 356    if (!bit) {
 357       _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
 358       _mesa_exit(1);
 359    }
 360
 361    if (bit > p->program->Base.NumTemporaries)
 362       p->program->Base.NumTemporaries = bit;
 363
 364    p->temp_in_use |= 1<<(bit-1);
 365    return make_ureg(PROGRAM_TEMPORARY, (bit-1));
 366 }
 367
 368 static struct ureg get_tex_temp( struct texenv_fragment_program *p )
 369 {
 370    int bit;
 371
 372    /* First try to find availble temp not previously used (to avoid
 373     * starting a new texture indirection).  According to the spec, the
 374     * ~p->temps_output isn't necessary, but will keep it there for
 375     * now:
 376     */
 377    bit = _mesa_ffs( ~p->temp_in_use & ~p->alu_temps & ~p->temps_output );
 378
 379    /* Then any unused temporary:
 380     */
 381    if (!bit)
 382       bit = _mesa_ffs( ~p->temp_in_use );
 383
 384    if (!bit) {
 385       _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
 386       _mesa_exit(1);
 387    }
 388
 389    if (bit > p->program->Base.NumTemporaries)
 390       p->program->Base.NumTemporaries = bit;
 391
 392    p->temp_in_use |= 1<<(bit-1);
 393    return make_ureg(PROGRAM_TEMPORARY, (bit-1));
 394 }
 395
 396
 397 static void release_temps( struct texenv_fragment_program *p )
 398 {
 399    GLuint max_temp = p->ctx->Const.FragmentProgram.MaxTemps;
 400
 401    /* KW: To support tex_env_crossbar, don't release the registers in
 402     * temps_output.
 403     */
 404    if (max_temp >= sizeof(int) * 8)
 405       p->temp_in_use = p->temps_output;
 406    else
 407       p->temp_in_use = ~((1<<max_temp)-1) | p->temps_output;
 408 }
 409
 410
 411 static struct ureg register_param6( struct texenv_fragment_program *p,
 412                                     GLint s0,
 413                                     GLint s1,
 414                                     GLint s2,
 415                                     GLint s3,
 416                                     GLint s4,
 417                                     GLint s5)
 418 {
 419    GLint tokens[6];
 420    GLuint idx;
 421    tokens[0] = s0;
 422    tokens[1] = s1;
 423    tokens[2] = s2;
 424    tokens[3] = s3;
 425    tokens[4] = s4;
 426    tokens[5] = s5;
 427    idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );
 428    return make_ureg(PROGRAM_STATE_VAR, idx);
 429 }
 430
 431
 432 #define register_param1(p,s0)          register_param6(p,s0,0,0,0,0,0)
 433 #define register_param2(p,s0,s1)       register_param6(p,s0,s1,0,0,0,0)
 434 #define register_param3(p,s0,s1,s2)    register_param6(p,s0,s1,s2,0,0,0)
 435 #define register_param4(p,s0,s1,s2,s3) register_param6(p,s0,s1,s2,s3,0,0)
 436
 437
 438 static struct ureg register_input( struct texenv_fragment_program *p, GLuint input )
 439 {
 440    p->program->Base.InputsRead |= (1 << input);
 441    return make_ureg(PROGRAM_INPUT, input);
 442 }
 443
 444
 445 static void emit_arg( struct prog_src_register *reg,
 446                       struct ureg ureg )
 447 {
 448    reg->File = ureg.file;
 449    reg->Index = ureg.idx;
 450    reg->Swizzle = ureg.swz;
 451    reg->NegateBase = ureg.negatebase ? 0xf : 0x0;
 452    reg->Abs = ureg.abs;
 453    reg->NegateAbs = ureg.negateabs;
 454 }
 455
 456 static void emit_dst( struct prog_dst_register *dst,
 457                       struct ureg ureg, GLuint mask )
 458 {
 459    dst->File = ureg.file;
 460    dst->Index = ureg.idx;
 461    dst->WriteMask = mask;
 462    dst->CondMask = 0;
 463    dst->CondSwizzle = 0;
 464 }
 465
 466 static struct prog_instruction *
 467 emit_op(struct texenv_fragment_program *p,
 468         enum prog_opcode op,
 469         struct ureg dest,
 470         GLuint mask,
 471         GLboolean saturate,
 472         struct ureg src0,
 473         struct ureg src1,
 474         struct ureg src2 )
 475 {
 476    GLuint nr = p->program->Base.NumInstructions++;
 477    struct prog_instruction *inst = &p->program->Base.Instructions[nr];
 478
 479    _mesa_init_instruction(inst);
 480    inst->Opcode = op;
 481
 482    emit_arg( &inst->SrcReg[0], src0 );
 483    emit_arg( &inst->SrcReg[1], src1 );
 484    emit_arg( &inst->SrcReg[2], src2 );
 485
 486    inst->SaturateMode = saturate ? SATURATE_ZERO_ONE : SATURATE_OFF;
 487
 488    emit_dst( &inst->DstReg, dest, mask );
 489
 490    /* Accounting for indirection tracking:
 491     */
 492    if (dest.file == PROGRAM_TEMPORARY)
 493       p->temps_output |= 1 << dest.idx;
 494
 495    return inst;
 496 }
 497
 498
 499 static struct ureg emit_arith( struct texenv_fragment_program *p,
 500                                enum prog_opcode op,
 501                                struct ureg dest,
 502                                GLuint mask,
 503                                GLboolean saturate,
 504                                struct ureg src0,
 505                                struct ureg src1,
 506                                struct ureg src2 )
 507 {
 508    emit_op(p, op, dest, mask, saturate, src0, src1, src2);
 509
 510    /* Accounting for indirection tracking:
 511     */
 512    if (src0.file == PROGRAM_TEMPORARY)
 513       p->alu_temps |= 1 << src0.idx;
 514
 515    if (!is_undef(src1) && src1.file == PROGRAM_TEMPORARY)
 516       p->alu_temps |= 1 << src1.idx;
 517
 518    if (!is_undef(src2) && src2.file == PROGRAM_TEMPORARY)
 519       p->alu_temps |= 1 << src2.idx;
 520
 521    if (dest.file == PROGRAM_TEMPORARY)
 522       p->alu_temps |= 1 << dest.idx;
 523
 524    p->program->NumAluInstructions++;
 525    return dest;
 526 }
 527
 528 static struct ureg emit_texld( struct texenv_fragment_program *p,
 529                                enum prog_opcode op,
 530                                struct ureg dest,
 531                                GLuint destmask,
 532                                GLuint tex_unit,
 533                                GLuint tex_idx,
 534                                struct ureg coord )
 535 {
 536    struct prog_instruction *inst = emit_op( p, op,
 537                                           dest, destmask,
 538                                           GL_FALSE,     /* don't saturate? */
 539                                           coord,        /* arg 0? */
 540                                           undef,
 541                                           undef);
 542
 543    inst->TexSrcTarget = tex_idx;
 544    inst->TexSrcUnit = tex_unit;
 545
 546    p->program->NumTexInstructions++;
 547
 548    /* Is this a texture indirection?
 549     */
 550    if ((coord.file == PROGRAM_TEMPORARY &&
 551         (p->temps_output & (1<<coord.idx))) ||
 552        (dest.file == PROGRAM_TEMPORARY &&
 553         (p->alu_temps & (1<<dest.idx)))) {
 554       p->program->NumTexIndirections++;
 555       p->temps_output = 1<<coord.idx;
 556       p->alu_temps = 0;
 557       assert(0);                /* KW: texture env crossbar */
 558    }
 559
 560    return dest;
 561 }
 562
 563
 564 static struct ureg register_const4f( struct texenv_fragment_program *p,
 565                                      GLfloat s0,
 566                                      GLfloat s1,
 567                                      GLfloat s2,
 568                                      GLfloat s3)
 569 {
 570    GLfloat values[4];
 571    GLuint idx;
 572    values[0] = s0;
 573    values[1] = s1;
 574    values[2] = s2;
 575    values[3] = s3;
 576    idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values );
 577    return make_ureg(PROGRAM_STATE_VAR, idx);
 578 }
 579
 580 #define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)
 581 #define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)
 582 #define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)
 583 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
 584
 585
 586 static struct ureg get_one( struct texenv_fragment_program *p )
 587 {
 588    if (is_undef(p->one))
 589       p->one = register_scalar_const(p, 1.0);
 590    return p->one;
 591 }
 592
 593 static struct ureg get_half( struct texenv_fragment_program *p )
 594 {
 595    if (is_undef(p->half))
 596       p->half = register_scalar_const(p, 0.5);
 597    return p->half;
 598 }
 599
 600 static struct ureg get_zero( struct texenv_fragment_program *p )
 601 {
 602    if (is_undef(p->zero))
 603       p->zero = register_scalar_const(p, 0.0);
 604    return p->zero;
 605 }
 606
 607
 608 static void program_error( struct texenv_fragment_program *p, const char *msg )
 609 {
 610    _mesa_problem(NULL, msg);
 611    p->error = 1;
 612 }
 613
 614 static struct ureg get_source( struct texenv_fragment_program *p,
 615                                GLuint src, GLuint unit )
 616 {
 617    switch (src) {
 618    case SRC_TEXTURE:
 619       assert(!is_undef(p->src_texture[unit]));
 620       return p->src_texture[unit];
 621
 622    case SRC_TEXTURE0:
 623    case SRC_TEXTURE1:
 624    case SRC_TEXTURE2:
 625    case SRC_TEXTURE3:
 626    case SRC_TEXTURE4:
 627    case SRC_TEXTURE5:
 628    case SRC_TEXTURE6:
 629    case SRC_TEXTURE7:
 630       assert(!is_undef(p->src_texture[src - SRC_TEXTURE0]));
 631       return p->src_texture[src - SRC_TEXTURE0];
 632
 633    case SRC_CONSTANT:
 634       return register_param2(p, STATE_TEXENV_COLOR, unit);
 635
 636    case SRC_PRIMARY_COLOR:
 637       return register_input(p, FRAG_ATTRIB_COL0);
 638
 639    case SRC_PREVIOUS:
 640    default:
 641       if (is_undef(p->src_previous))
 642          return register_input(p, FRAG_ATTRIB_COL0);
 643       else
 644          return p->src_previous;
 645    }
 646 }
 647
 648 static struct ureg emit_combine_source( struct texenv_fragment_program *p,
 649                                         GLuint mask,
 650                                         GLuint unit,
 651                                         GLuint source,
 652                                         GLuint operand )
 653 {
 654    struct ureg arg, src, one;
 655
 656    src = get_source(p, source, unit);
 657
 658    switch (operand) {
 659    case OPR_ONE_MINUS_SRC_COLOR:
 660       /* Get unused tmp,
 661        * Emit tmp = 1.0 - arg.xyzw
 662        */
 663       arg = get_temp( p );
 664       one = get_one( p );
 665       return emit_arith( p, OPCODE_SUB, arg, mask, 0, one, src, undef);
 666
 667    case OPR_SRC_ALPHA:
 668       if (mask == WRITEMASK_W)
 669          return src;
 670       else
 671          return swizzle1( src, SWIZZLE_W );
 672    case OPR_ONE_MINUS_SRC_ALPHA:
 673       /* Get unused tmp,
 674        * Emit tmp = 1.0 - arg.wwww
 675        */
 676       arg = get_temp(p);
 677       one = get_one(p);
 678       return emit_arith(p, OPCODE_SUB, arg, mask, 0,
 679                         one, swizzle1(src, SWIZZLE_W), undef);
 680    case OPR_ZERO:
 681       return get_zero(p);
 682    case OPR_ONE:
 683       return get_one(p);
 684    case OPR_SRC_COLOR:
 685    default:
 686       return src;
 687    }
 688 }
 689
 690 static GLboolean args_match( struct state_key *key, GLuint unit )
 691 {
 692    GLuint i, nr = key->unit[unit].NumArgsRGB;
 693
 694    for (i = 0 ; i < nr ; i++) {
 695       if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source)
 696          return GL_FALSE;
 697
 698       switch(key->unit[unit].OptA[i].Operand) {
 699       case OPR_SRC_ALPHA:
 700          switch(key->unit[unit].OptRGB[i].Operand) {
 701          case OPR_SRC_COLOR:
 702          case OPR_SRC_ALPHA:
 703             break;
 704          default:
 705             return GL_FALSE;
 706          }
 707          break;
 708       case OPR_ONE_MINUS_SRC_ALPHA:
 709          switch(key->unit[unit].OptRGB[i].Operand) {
 710          case OPR_ONE_MINUS_SRC_COLOR:
 711          case OPR_ONE_MINUS_SRC_ALPHA:
 712             break;
 713          default:
 714             return GL_FALSE;
 715          }
 716          break;
 717       default:
 718          return GL_FALSE;       /* impossible */
 719       }
 720    }
 721
 722    return GL_TRUE;
 723 }
 724
 725 static struct ureg emit_combine( struct texenv_fragment_program *p,
 726                                  struct ureg dest,
 727                                  GLuint mask,
 728                                  GLboolean saturate,
 729                                  GLuint unit,
 730                                  GLuint nr,
 731                                  GLuint mode,
 732                                  struct mode_opt *opt)
 733 {
 734    struct ureg src[3];
 735    struct ureg tmp, half;
 736    GLuint i;
 737
 738    tmp = undef; /* silence warning (bug 5318) */
 739
 740    for (i = 0; i < nr; i++)
 741       src[i] = emit_combine_source( p, mask, unit, opt[i].Source, opt[i].Operand );
 742
 743    switch (mode) {
 744    case MODE_REPLACE:
 745       if (mask == WRITEMASK_XYZW && !saturate)
 746          return src[0];
 747       else
 748          return emit_arith( p, OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );
 749    case MODE_MODULATE:
 750       return emit_arith( p, OPCODE_MUL, dest, mask, saturate,
 751                          src[0], src[1], undef );
 752    case MODE_ADD:
 753       return emit_arith( p, OPCODE_ADD, dest, mask, saturate,
 754                          src[0], src[1], undef );
 755    case MODE_ADD_SIGNED:
 756       /* tmp = arg0 + arg1
 757        * result = tmp - .5
 758        */
 759       half = get_half(p);
 760       tmp = get_temp( p );
 761       emit_arith( p, OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );
 762       emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp, half, undef );
 763       return dest;
 764    case MODE_INTERPOLATE:
 765       /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:
 766        */
 767       return emit_arith( p, OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );
 768
 769    case MODE_SUBTRACT:
 770       return emit_arith( p, OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );
 771
 772    case MODE_DOT3_RGBA:
 773    case MODE_DOT3_RGBA_EXT:
 774    case MODE_DOT3_RGB_EXT:
 775    case MODE_DOT3_RGB: {
 776       struct ureg tmp0 = get_temp( p );
 777       struct ureg tmp1 = get_temp( p );
 778       struct ureg neg1 = register_scalar_const(p, -1);
 779       struct ureg two  = register_scalar_const(p, 2);
 780
 781       /* tmp0 = 2*src0 - 1
 782        * tmp1 = 2*src1 - 1
 783        *
 784        * dst = tmp0 dot3 tmp1
 785        */
 786       emit_arith( p, OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0,
 787                   two, src[0], neg1);
 788
 789       if (_mesa_memcmp(&src[0], &src[1], sizeof(struct ureg)) == 0)
 790          tmp1 = tmp0;
 791       else
 792          emit_arith( p, OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0,
 793                      two, src[1], neg1);
 794       emit_arith( p, OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);
 795       return dest;
 796    }
 797    case MODE_MODULATE_ADD_ATI:
 798       /* Arg0 * Arg2 + Arg1 */
 799       return emit_arith( p, OPCODE_MAD, dest, mask, saturate,
 800                          src[0], src[2], src[1] );
 801    case MODE_MODULATE_SIGNED_ADD_ATI: {
 802       /* Arg0 * Arg2 + Arg1 - 0.5 */
 803       struct ureg tmp0 = get_temp(p);
 804       half = get_half(p);
 805       emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );
 806       emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
 807       return dest;
 808    }
 809    case MODE_MODULATE_SUBTRACT_ATI:
 810       /* Arg0 * Arg2 - Arg1 */
 811       emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );
 812       return dest;
 813    default:
 814       return src[0];
 815    }
 816 }
 817
 818
 819 /**
 820  * Generate instructions for one texture unit's env/combiner mode.
 821  */
 822 static struct ureg
 823 emit_texenv(struct texenv_fragment_program *p, GLuint unit)
 824 {
 825    struct state_key *key = p->state;
 826    GLboolean saturate = (unit < p->last_tex_stage);
 827    GLuint rgb_shift, alpha_shift;
 828    struct ureg out, shift;
 829    struct ureg dest;
 830
 831    if (!key->unit[unit].enabled) {
 832       return get_source(p, SRC_PREVIOUS, 0);
 833    }
 834
 835    switch (key->unit[unit].ModeRGB) {
 836    case MODE_DOT3_RGB_EXT:
 837       alpha_shift = key->unit[unit].ScaleShiftA;
 838       rgb_shift = 0;
 839       break;
 840    case MODE_DOT3_RGBA_EXT:
 841       alpha_shift = 0;
 842       rgb_shift = 0;
 843       break;
 844    default:
 845       rgb_shift = key->unit[unit].ScaleShiftRGB;
 846       alpha_shift = key->unit[unit].ScaleShiftA;
 847       break;
 848    }
 849
 850    /* If this is the very last calculation, emit direct to output reg:
 851     */
 852    if (key->separate_specular ||
 853        unit != p->last_tex_stage ||
 854        alpha_shift ||
 855        rgb_shift)
 856       dest = get_temp( p );
 857    else
 858       dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLR);
 859
 860    /* Emit the RGB and A combine ops
 861     */
 862    if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&
 863        args_match(key, unit)) {
 864       out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
 865                           unit,
 866                           key->unit[unit].NumArgsRGB,
 867                           key->unit[unit].ModeRGB,
 868                           key->unit[unit].OptRGB);
 869    }
 870    else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
 871             key->unit[unit].ModeA == MODE_DOT3_RGBA) {
 872
 873       out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
 874                           unit,
 875                           key->unit[unit].NumArgsRGB,
 876                           key->unit[unit].ModeRGB,
 877                           key->unit[unit].OptRGB);
 878    }
 879    else {
 880       /* Need to do something to stop from re-emitting identical
 881        * argument calculations here:
 882        */
 883       out = emit_combine( p, dest, WRITEMASK_XYZ, saturate,
 884                           unit,
 885                           key->unit[unit].NumArgsRGB,
 886                           key->unit[unit].ModeRGB,
 887                           key->unit[unit].OptRGB);
 888       out = emit_combine( p, dest, WRITEMASK_W, saturate,
 889                           unit,
 890                           key->unit[unit].NumArgsA,
 891                           key->unit[unit].ModeA,
 892                           key->unit[unit].OptA);
 893    }
 894
 895    /* Deal with the final shift:
 896     */
 897    if (alpha_shift || rgb_shift) {
 898       if (rgb_shift == alpha_shift) {
 899          shift = register_scalar_const(p, 1<<rgb_shift);
 900       }
 901       else {
 902          shift = register_const4f(p,
 903                                   1<<rgb_shift,
 904                                   1<<rgb_shift,
 905                                   1<<rgb_shift,
 906                                   1<<alpha_shift);
 907       }
 908       return emit_arith( p, OPCODE_MUL, dest, WRITEMASK_XYZW,
 909                          saturate, out, shift, undef );
 910    }
 911    else
 912       return out;
 913 }
 914
 915
 916 /**
 917  * Generate instruction for getting a texture source term.
 918  */
 919 static void load_texture( struct texenv_fragment_program *p, GLuint unit )
 920 {
 921    if (is_undef(p->src_texture[unit])) {
 922       GLuint dim = p->state->unit[unit].source_index;
 923       struct ureg texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);
 924       struct ureg tmp = get_tex_temp( p );
 925
 926       if (dim == TEXTURE_UNKNOWN_INDEX)
 927          program_error(p, "TexSrcBit");
 928
 929       /* TODO: Use D0_MASK_XY where possible.
 930        */
 931       p->src_texture[unit] = emit_texld( p, OPCODE_TXP,
 932                                          tmp, WRITEMASK_XYZW,
 933                                          unit, dim, texcoord );
 934    }
 935 }
 936
 937 static GLboolean load_texenv_source( struct texenv_fragment_program *p,
 938                                      GLuint src, GLuint unit )
 939 {
 940    switch (src) {
 941    case SRC_TEXTURE:
 942       load_texture(p, unit);
 943       break;
 944
 945    case SRC_TEXTURE0:
 946    case SRC_TEXTURE1:
 947    case SRC_TEXTURE2:
 948    case SRC_TEXTURE3:
 949    case SRC_TEXTURE4:
 950    case SRC_TEXTURE5:
 951    case SRC_TEXTURE6:
 952    case SRC_TEXTURE7:
 953       if (!p->state->unit[src - SRC_TEXTURE0].enabled)
 954          return GL_FALSE;
 955       load_texture(p, src - SRC_TEXTURE0);
 956       break;
 957
 958    default:
 959       break;
 960    }
 961
 962    return GL_TRUE;
 963 }
 964
 965
 966 /**
 967  * Generate instructions for loading all texture source terms.
 968  */
 969 static GLboolean
 970 load_texunit_sources( struct texenv_fragment_program *p, int unit )
 971 {
 972    struct state_key *key = p->state;
 973    int i, nr = key->unit[unit].NumArgsRGB;
 974    for (i = 0; i < nr; i++) {
 975       if (!load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit) ||
 976           !load_texenv_source( p, key->unit[unit].OptA[i].Source, unit ))
 977          return GL_FALSE;
 978    }
 979    return GL_TRUE;
 980 }
 981
 982
 983 /**
 984  * Generate a new fragment program which implements the context's
 985  * current texture env/combine mode.
 986  */
 987 static void
 988 create_new_program(struct state_key *key, GLcontext *ctx,
 989                    struct fragment_program *program)
 990 {
 991    struct texenv_fragment_program p;
 992    GLuint unit;
 993    struct ureg cf, out;
 994
 995    _mesa_memset(&p, 0, sizeof(p));
 996    p.ctx = ctx;
 997    p.state = key;
 998    p.program = program;
 999
1000    p.program->Base.Instructions =
1001       (struct prog_instruction*) _mesa_malloc(sizeof(struct prog_instruction) * MAX_INSTRUCTIONS);
1002    p.program->Base.NumInstructions = 0;
1003    p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;
1004    p.program->NumTexIndirections = 1;   /* correct? */
1005    p.program->NumTexInstructions = 0;
1006    p.program->NumAluInstructions = 0;
1007    p.program->Base.String = 0;
1008    p.program->Base.NumInstructions =
1009       p.program->Base.NumTemporaries =
1010       p.program->Base.NumParameters =
1011       p.program->Base.NumAttributes = p.program->Base.NumAddressRegs = 0;
1012    p.program->Base.Parameters = _mesa_new_parameter_list();
1013
1014    p.program->Base.InputsRead = 0;
1015    p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLR;
1016
1017    for (unit = 0; unit < MAX_TEXTURE_UNITS; unit++)
1018       p.src_texture[unit] = undef;
1019
1020    p.src_previous = undef;
1021    p.last_tex_stage = 0;
1022    release_temps(&p);
1023
1024    if (key->enabled_units) {
1025       /* First pass - to support texture_env_crossbar, first identify
1026        * all referenced texture sources and emit texld instructions
1027        * for each:
1028        */
1029       for (unit = 0 ; unit < ctx->Const.MaxTextureUnits ; unit++)
1030          if (key->unit[unit].enabled) {
1031             if (load_texunit_sources( &p, unit ))
1032                p.last_tex_stage = unit;
1033          }
1034
1035       /* Second pass - emit combine instructions to build final color:
1036        */
1037       for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++)
1038          if (key->enabled_units & (1<<unit)) {
1039             p.src_previous = emit_texenv( &p, unit );
1040             release_temps(&p);  /* release all temps */
1041          }
1042    }
1043
1044    cf = get_source( &p, SRC_PREVIOUS, 0 );
1045    out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLR );
1046
1047    if (key->separate_specular) {
1048       /* Emit specular add.
1049        */
1050       struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);
1051       emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
1052       emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
1053    }
1054    else if (_mesa_memcmp(&cf, &out, sizeof(cf)) != 0) {
1055       /* Will wind up in here if no texture enabled or a couple of
1056        * other scenarios (GL_REPLACE for instance).
1057        */
1058       emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
1059    }
1060
1061    /* Finish up:
1062     */
1063    emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);
1064
1065    if (key->fog_enabled) {
1066       /* Pull fog mode from GLcontext, the value in the state key is
1067        * a reduced value and not what is expected in FogOption
1068        */
1069       p.program->FogOption = ctx->Fog.Mode;
1070    } else
1071       p.program->FogOption = GL_NONE;
1072
1073    if (p.program->NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections)
1074       program_error(&p, "Exceeded max nr indirect texture lookups");
1075
1076    if (p.program->NumTexInstructions > ctx->Const.FragmentProgram.MaxTexInstructions)
1077       program_error(&p, "Exceeded max TEX instructions");
1078
1079    if (p.program->NumAluInstructions > ctx->Const.FragmentProgram.MaxAluInstructions)
1080       program_error(&p, "Exceeded max ALU instructions");
1081
1082    ASSERT(p.program->Base.NumInstructions <= MAX_INSTRUCTIONS);
1083
1084    /* Notify driver the fragment program has (actually) changed.
1085     */
1086    if (ctx->Driver.ProgramStringNotify || DISASSEM) {
1087       if (ctx->Driver.ProgramStringNotify)
1088          ctx->Driver.ProgramStringNotify( ctx, GL_FRAGMENT_PROGRAM_ARB,
1089                                           &p.program->Base );
1090
1091       if (DISASSEM) {
1092          _mesa_print_program(&p.program->Base);
1093          _mesa_printf("\n");
1094       }
1095    }
1096 }
1097
1098
1099 static void *search_cache( struct texenvprog_cache *cache,
1100                            GLuint hash,
1101                            const void *key,
1102                            GLuint keysize)
1103 {
1104    struct texenvprog_cache *c;
1105
1106    for (c = cache; c; c = c->next) {
1107       if (c->hash == hash && _mesa_memcmp(c->key, key, keysize) == 0)
1108          return c->data;
1109    }
1110
1111    return NULL;
1112 }
1113
1114 static void cache_item( struct texenvprog_cache **cache,
1115                         GLuint hash,
1116                         void *key,
1117                         void *data )
1118 {
1119    struct texenvprog_cache *c = CALLOC_STRUCT(texenvprog_cache);
1120    c->hash = hash;
1121    c->key = key;
1122    c->data = data;
1123    c->next = *cache;
1124    *cache = c;
1125 }
1126
1127 static GLuint hash_key( struct state_key *key )
1128 {
1129    GLuint *ikey = (GLuint *)key;
1130    GLuint hash = 0, i;
1131
1132    /* I'm sure this can be improved on, but speed is important:
1133     */
1134    for (i = 0; i < sizeof(*key)/sizeof(GLuint); i++)
1135       hash ^= ikey[i];
1136
1137    return hash;
1138 }
1139
1140 void _mesa_UpdateTexEnvProgram( GLcontext *ctx )
1141 {
1142    struct state_key *key;
1143    GLuint hash;
1144    struct fragment_program *prev = ctx->FragmentProgram._Current;
1145
1146    if (!ctx->FragmentProgram._Enabled) {
1147       key = make_state_key(ctx);
1148       hash = hash_key(key);
1149
1150       ctx->FragmentProgram._Current = ctx->_TexEnvProgram =
1151          (struct fragment_program *)
1152          search_cache(ctx->Texture.env_fp_cache, hash, key, sizeof(*key));
1153
1154       if (!ctx->_TexEnvProgram) {
1155          if (0) _mesa_printf("Building new texenv proggy for key %x\n", hash);
1156
1157          ctx->FragmentProgram._Current = ctx->_TexEnvProgram =
1158             (struct fragment_program *)
1159             ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
1160
1161          create_new_program(key, ctx, ctx->_TexEnvProgram);
1162
1163          cache_item(&ctx->Texture.env_fp_cache, hash, key, ctx->_TexEnvProgram);
1164       } else {
1165          _mesa_free(key);
1166          if (0) _mesa_printf("Found existing texenv program for key %x\n", hash);
1167       }
1168    }
1169    else {
1170       ctx->FragmentProgram._Current = ctx->FragmentProgram.Current;
1171    }
1172
1173    /* Tell the driver about the change.  Could define a new target for
1174     * this?
1175     */
1176    if (ctx->FragmentProgram._Current != prev && ctx->Driver.BindProgram) {
1177       ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
1178                              (struct program *) ctx->FragmentProgram._Current);
1179    }
1180 }
1181
1182 void _mesa_TexEnvProgramCacheDestroy( GLcontext *ctx )
1183 {
1184    struct texenvprog_cache *a, *tmp;
1185
1186    for (a = ctx->Texture.env_fp_cache; a; a = tmp) {
1187       tmp = a->next;
1188       _mesa_free(a->key);
1189       ctx->Driver.DeleteProgram(ctx, (struct program *) a->data);
1190       _mesa_free(a);
1191    }
1192 }