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