src/mesa/swrast/s_atifragshader.c

   1 /*
   2  *
   3  * Copyright (C) 2004  David Airlie   All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included
  13  * in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * DAVID AIRLIE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  19  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 #include "glheader.h"
  24 #include "colormac.h"
  25 #include "context.h"
  26 #include "atifragshader.h"
  27 #include "macros.h"
  28 #include "program.h"
  29
  30 #include "s_atifragshader.h"
  31
  32
  33 /**
  34  * State for executing ATI fragment shader.
  35  */
  36 struct atifs_machine
  37 {
  38    GLfloat Registers[6][4];         /** six temporary registers */
  39    GLfloat PrevPassRegisters[6][4];
  40    GLfloat Inputs[2][4];   /** Primary, secondary input colors */
  41 };
  42
  43
  44
  45 /**
  46  * Fetch a texel.
  47  */
  48 static void
  49 fetch_texel(GLcontext * ctx, const GLfloat texcoord[4], GLfloat lambda,
  50             GLuint unit, GLfloat color[4])
  51 {
  52    GLchan rgba[4];
  53    SWcontext *swrast = SWRAST_CONTEXT(ctx);
  54
  55    /* XXX use a float-valued TextureSample routine here!!! */
  56    swrast->TextureSample[unit](ctx, ctx->Texture.Unit[unit]._Current,
  57                                1, (const GLfloat(*)[4]) texcoord,
  58                                &lambda, &rgba);
  59    color[0] = CHAN_TO_FLOAT(rgba[0]);
  60    color[1] = CHAN_TO_FLOAT(rgba[1]);
  61    color[2] = CHAN_TO_FLOAT(rgba[2]);
  62    color[3] = CHAN_TO_FLOAT(rgba[3]);
  63 }
  64
  65 static void
  66 apply_swizzle(GLfloat values[4], GLuint swizzle)
  67 {
  68    GLfloat s, t, r, q;
  69
  70    s = values[0];
  71    t = values[1];
  72    r = values[2];
  73    q = values[3];
  74
  75    switch (swizzle) {
  76    case GL_SWIZZLE_STR_ATI:
  77       values[0] = s;
  78       values[1] = t;
  79       values[2] = r;
  80       break;
  81    case GL_SWIZZLE_STQ_ATI:
  82       values[0] = s;
  83       values[1] = t;
  84       values[2] = q;
  85       break;
  86    case GL_SWIZZLE_STR_DR_ATI:
  87       values[0] = s / r;
  88       values[1] = t / r;
  89       values[2] = 1 / r;
  90       break;
  91    case GL_SWIZZLE_STQ_DQ_ATI:
  92 /* make sure q is not 0 to avoid problems later with infinite values (texture lookup)? */
  93       if (q == 0.0F) q = 0.000000001;
  94       values[0] = s / q;
  95       values[1] = t / q;
  96       values[2] = 1 / q;
  97       break;
  98    }
  99    values[3] = 0.0;
 100 }
 101
 102 static void
 103 apply_src_rep(GLint optype, GLuint rep, GLfloat * val)
 104 {
 105    GLint i;
 106    GLint start, end;
 107    if (!rep)
 108       return;
 109
 110    start = optype ? 3 : 0;
 111    end = 4;
 112
 113    for (i = start; i < end; i++) {
 114       switch (rep) {
 115       case GL_RED:
 116          val[i] = val[0];
 117          break;
 118       case GL_GREEN:
 119          val[i] = val[1];
 120          break;
 121       case GL_BLUE:
 122          val[i] = val[2];
 123          break;
 124       case GL_ALPHA:
 125          val[i] = val[3];
 126          break;
 127       }
 128    }
 129 }
 130
 131 static void
 132 apply_src_mod(GLint optype, GLuint mod, GLfloat * val)
 133 {
 134    GLint i;
 135    GLint start, end;
 136
 137    if (!mod)
 138       return;
 139
 140    start = optype ? 3 : 0;
 141    end = 4;
 142
 143    for (i = start; i < end; i++) {
 144       if (mod & GL_COMP_BIT_ATI)
 145          val[i] = 1 - val[i];
 146
 147       if (mod & GL_BIAS_BIT_ATI)
 148          val[i] = val[i] - 0.5;
 149
 150       if (mod & GL_2X_BIT_ATI)
 151          val[i] = 2 * val[i];
 152
 153       if (mod & GL_NEGATE_BIT_ATI)
 154          val[i] = -val[i];
 155    }
 156 }
 157
 158 static void
 159 apply_dst_mod(GLuint optype, GLuint mod, GLfloat * val)
 160 {
 161    GLint i;
 162    GLint has_sat = mod & GL_SATURATE_BIT_ATI;
 163    GLint start, end;
 164
 165    mod &= ~GL_SATURATE_BIT_ATI;
 166
 167    start = optype ? 3 : 0;
 168    end = optype ? 4 : 3;
 169
 170    for (i = start; i < end; i++) {
 171       switch (mod) {
 172       case GL_2X_BIT_ATI:
 173          val[i] = 2 * val[i];
 174          break;
 175       case GL_4X_BIT_ATI:
 176          val[i] = 4 * val[i];
 177          break;
 178       case GL_8X_BIT_ATI:
 179          val[i] = 8 * val[i];
 180          break;
 181       case GL_HALF_BIT_ATI:
 182          val[i] = val[i] * 0.5;
 183          break;
 184       case GL_QUARTER_BIT_ATI:
 185          val[i] = val[i] * 0.25;
 186          break;
 187       case GL_EIGHTH_BIT_ATI:
 188          val[i] = val[i] * 0.125;
 189          break;
 190       }
 191
 192       if (has_sat) {
 193          if (val[i] < 0.0)
 194             val[i] = 0;
 195          else if (val[i] > 1.0)
 196             val[i] = 1.0;
 197       }
 198       else {
 199          if (val[i] < -8.0)
 200             val[i] = -8.0;
 201          else if (val[i] > 8.0)
 202             val[i] = 8.0;
 203       }
 204    }
 205 }
 206
 207
 208 static void
 209 write_dst_addr(GLuint optype, GLuint mod, GLuint mask, GLfloat * src,
 210                GLfloat * dst)
 211 {
 212    GLint i;
 213    apply_dst_mod(optype, mod, src);
 214
 215    if (optype == ATI_FRAGMENT_SHADER_COLOR_OP) {
 216       if (mask) {
 217          if (mask & GL_RED_BIT_ATI)
 218             dst[0] = src[0];
 219
 220          if (mask & GL_GREEN_BIT_ATI)
 221             dst[1] = src[1];
 222
 223          if (mask & GL_BLUE_BIT_ATI)
 224             dst[2] = src[2];
 225       }
 226       else {
 227          for (i = 0; i < 3; i++)
 228             dst[i] = src[i];
 229       }
 230    }
 231    else
 232       dst[3] = src[3];
 233 }
 234
 235 static void
 236 finish_pass(struct atifs_machine *machine)
 237 {
 238    GLint i;
 239
 240    for (i = 0; i < 6; i++) {
 241       COPY_4V(machine->PrevPassRegisters[i], machine->Registers[i]);
 242    }
 243 }
 244
 245 /**
 246  * Execute the given fragment shader
 247  * NOTE: we do everything in single-precision floating point; we don't
 248  * currently observe the single/half/fixed-precision qualifiers.
 249  * \param ctx - rendering context
 250  * \param program - the fragment program to execute
 251  * \param machine - machine state (register file)
 252  * \param maxInst - max number of instructions to execute
 253  * \return GL_TRUE if program completed or GL_FALSE if program executed KIL.
 254  */
 255
 256 struct ati_fs_opcode_st ati_fs_opcodes[] = {
 257    {GL_ADD_ATI, 2},
 258    {GL_SUB_ATI, 2},
 259    {GL_MUL_ATI, 2},
 260    {GL_MAD_ATI, 3},
 261    {GL_LERP_ATI, 3},
 262    {GL_MOV_ATI, 1},
 263    {GL_CND_ATI, 3},
 264    {GL_CND0_ATI, 3},
 265    {GL_DOT2_ADD_ATI, 3},
 266    {GL_DOT3_ATI, 2},
 267    {GL_DOT4_ATI, 2}
 268 };
 269
 270
 271
 272 static void
 273 handle_pass_op(struct atifs_machine *machine, struct atifs_setupinst *texinst,
 274                const SWspan *span, GLuint column, GLuint idx)
 275 {
 276    GLuint swizzle = texinst->swizzle;
 277    GLuint pass_tex = texinst->src;
 278
 279    if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) {
 280       pass_tex -= GL_TEXTURE0_ARB;
 281       COPY_4V(machine->Registers[idx],
 282               span->array->texcoords[pass_tex][column]);
 283    }
 284    else if (pass_tex >= GL_REG_0_ATI && pass_tex <= GL_REG_5_ATI) {
 285       pass_tex -= GL_REG_0_ATI;
 286       COPY_4V(machine->Registers[idx], machine->PrevPassRegisters[pass_tex]);
 287    }
 288    apply_swizzle(machine->Registers[idx], swizzle);
 289
 290 }
 291
 292 static void
 293 handle_sample_op(GLcontext * ctx, struct atifs_machine *machine,
 294                  struct atifs_setupinst *texinst, const SWspan *span,
 295                  GLuint column, GLuint idx)
 296 {
 297 /* sample from unit idx using texinst->src as coords */
 298    GLuint swizzle = texinst->swizzle;
 299    GLuint coord_source = texinst->src;
 300    GLfloat tex_coords[4];
 301
 302    if (coord_source >= GL_TEXTURE0_ARB && coord_source <= GL_TEXTURE7_ARB) {
 303       coord_source -= GL_TEXTURE0_ARB;
 304       COPY_4V(tex_coords, span->array->texcoords[coord_source][column]);
 305    }
 306    else if (coord_source >= GL_REG_0_ATI && coord_source <= GL_REG_5_ATI) {
 307       coord_source -= GL_REG_0_ATI;
 308       COPY_4V(tex_coords, machine->PrevPassRegisters[coord_source]);
 309    }
 310    apply_swizzle(tex_coords, swizzle);
 311    fetch_texel(ctx, tex_coords, 0.0F, idx, machine->Registers[idx]);
 312 }
 313
 314 #define SETUP_SRC_REG(optype, i, x)             \
 315 do {                                            \
 316    COPY_4V(src[optype][i], x);                  \
 317 } while (0)
 318
 319 static GLboolean
 320 execute_shader(GLcontext * ctx,
 321                const struct ati_fragment_shader *shader, GLuint maxInst,
 322                struct atifs_machine *machine, const SWspan *span,
 323                GLuint column)
 324 {
 325    GLuint pc;
 326    struct atifs_instruction *inst;
 327    struct atifs_setupinst *texinst;
 328    GLint optype;
 329    GLint i, j, pass;
 330    GLint dstreg;
 331    GLfloat src[2][3][4];
 332    GLfloat zeros[4] = { 0.0, 0.0, 0.0, 0.0 };
 333    GLfloat ones[4] = { 1.0, 1.0, 1.0, 1.0 };
 334    GLfloat dst[2][4], *dstp;
 335
 336    for (pass = 0; pass < shader->NumPasses; pass++) {
 337       if (pass > 0)
 338          finish_pass(machine);
 339       for (j = 0; j < MAX_NUM_FRAGMENT_REGISTERS_ATI; j++) {
 340          texinst = &shader->SetupInst[pass][j];
 341          if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP)
 342             handle_pass_op(machine, texinst, span, column, j);
 343          else if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP)
 344             handle_sample_op(ctx, machine, texinst, span, column, j);
 345       }
 346
 347       for (pc = 0; pc < shader->numArithInstr[pass]; pc++) {
 348          inst = &shader->Instructions[pass][pc];
 349
 350          /* setup the source registers for color and alpha ops */
 351          for (optype = 0; optype < 2; optype++) {
 352             for (i = 0; i < inst->ArgCount[optype]; i++) {
 353                GLint index = inst->SrcReg[optype][i].Index;
 354
 355                if (index >= GL_REG_0_ATI && index <= GL_REG_5_ATI)
 356                   SETUP_SRC_REG(optype, i,
 357                                 machine->Registers[index - GL_REG_0_ATI]);
 358                else if (index >= GL_CON_0_ATI && index <= GL_CON_7_ATI) {
 359                   if (shader->LocalConstDef & (1 << (index - GL_CON_0_ATI))) {
 360                      SETUP_SRC_REG(optype, i,
 361                                 shader->Constants[index - GL_CON_0_ATI]);
 362                   } else {
 363                      SETUP_SRC_REG(optype, i,
 364                                 ctx->ATIFragmentShader.GlobalConstants[index - GL_CON_0_ATI]);
 365                   }
 366                }
 367                else if (index == GL_ONE)
 368                   SETUP_SRC_REG(optype, i, ones);
 369                else if (index == GL_ZERO)
 370                   SETUP_SRC_REG(optype, i, zeros);
 371                else if (index == GL_PRIMARY_COLOR_EXT)
 372                   SETUP_SRC_REG(optype, i,
 373                                 machine->Inputs[ATI_FS_INPUT_PRIMARY]);
 374                else if (index == GL_SECONDARY_INTERPOLATOR_ATI)
 375                   SETUP_SRC_REG(optype, i,
 376                                 machine->Inputs[ATI_FS_INPUT_SECONDARY]);
 377
 378                apply_src_rep(optype, inst->SrcReg[optype][i].argRep,
 379                              src[optype][i]);
 380                apply_src_mod(optype, inst->SrcReg[optype][i].argMod,
 381                              src[optype][i]);
 382             }
 383          }
 384
 385          /* Execute the operations - color then alpha */
 386          for (optype = 0; optype < 2; optype++) {
 387             if (inst->Opcode[optype]) {
 388                switch (inst->Opcode[optype]) {
 389                case GL_ADD_ATI:
 390                   if (!optype)
 391                      for (i = 0; i < 3; i++) {
 392                         dst[optype][i] =
 393                            src[optype][0][i] + src[optype][1][i];
 394                      }
 395                   else
 396                      dst[optype][3] = src[optype][0][3] + src[optype][1][3];
 397                   break;
 398                case GL_SUB_ATI:
 399                   if (!optype)
 400                      for (i = 0; i < 3; i++) {
 401                         dst[optype][i] =
 402                            src[optype][0][i] - src[optype][1][i];
 403                      }
 404                   else
 405                      dst[optype][3] = src[optype][0][3] - src[optype][1][3];
 406                   break;
 407                case GL_MUL_ATI:
 408                   if (!optype)
 409                      for (i = 0; i < 3; i++) {
 410                         dst[optype][i] =
 411                            src[optype][0][i] * src[optype][1][i];
 412                      }
 413                   else
 414                      dst[optype][3] = src[optype][0][3] * src[optype][1][3];
 415                   break;
 416                case GL_MAD_ATI:
 417                   if (!optype)
 418                      for (i = 0; i < 3; i++) {
 419                         dst[optype][i] =
 420                            src[optype][0][i] * src[optype][1][i] +
 421                            src[optype][2][i];
 422                      }
 423                   else
 424                      dst[optype][3] =
 425                         src[optype][0][3] * src[optype][1][3] +
 426                         src[optype][2][3];
 427                   break;
 428                case GL_LERP_ATI:
 429                   if (!optype)
 430                      for (i = 0; i < 3; i++) {
 431                         dst[optype][i] =
 432                            src[optype][0][i] * src[optype][1][i] + (1 -
 433                                                                     src
 434                                                                     [optype]
 435                                                                     [0][i]) *
 436                            src[optype][2][i];
 437                      }
 438                   else
 439                      dst[optype][3] =
 440                         src[optype][0][3] * src[optype][1][3] + (1 -
 441                                                                  src[optype]
 442                                                                  [0][3]) *
 443                         src[optype][2][3];
 444                   break;
 445
 446                case GL_MOV_ATI:
 447                   if (!optype)
 448                      for (i = 0; i < 3; i++) {
 449                         dst[optype][i] = src[optype][0][i];
 450                      }
 451                   else
 452                      dst[optype][3] = src[optype][0][3];
 453                   break;
 454                case GL_CND_ATI:
 455                   if (!optype) {
 456                      for (i = 0; i < 3; i++) {
 457                         dst[optype][i] =
 458                            (src[optype][2][i] >
 459                             0.5) ? src[optype][0][i] : src[optype][1][i];
 460                      }
 461                   }
 462                   else {
 463                      dst[optype][3] =
 464                         (src[optype][2][3] >
 465                          0.5) ? src[optype][0][3] : src[optype][1][3];
 466                   }
 467                   break;
 468
 469                case GL_CND0_ATI:
 470                   if (!optype)
 471                      for (i = 0; i < 3; i++) {
 472                         dst[optype][i] =
 473                            (src[optype][2][i] >=
 474                             0) ? src[optype][0][i] : src[optype][1][i];
 475                      }
 476                   else {
 477                      dst[optype][3] =
 478                         (src[optype][2][3] >=
 479                          0) ? src[optype][0][3] : src[optype][1][3];
 480                   }
 481                   break;
 482                case GL_DOT2_ADD_ATI:
 483                   {
 484                      GLfloat result;
 485
 486                      /* DOT 2 always uses the source from the color op */
 487                      /* could save recalculation of dot products for alpha inst */
 488                      result = src[0][0][0] * src[0][1][0] +
 489                         src[0][0][1] * src[0][1][1] + src[0][2][2];
 490                      if (!optype) {
 491                         for (i = 0; i < 3; i++) {
 492                            dst[optype][i] = result;
 493                         }
 494                      }
 495                      else
 496                         dst[optype][3] = result;
 497                   }
 498                   break;
 499                case GL_DOT3_ATI:
 500                   {
 501                      GLfloat result;
 502
 503                      /* DOT 3 always uses the source from the color op */
 504                      result = src[0][0][0] * src[0][1][0] +
 505                         src[0][0][1] * src[0][1][1] +
 506                         src[0][0][2] * src[0][1][2];
 507
 508                      if (!optype) {
 509                         for (i = 0; i < 3; i++) {
 510                            dst[optype][i] = result;
 511                         }
 512                      }
 513                      else
 514                         dst[optype][3] = result;
 515                   }
 516                   break;
 517                case GL_DOT4_ATI:
 518                   {
 519                      GLfloat result;
 520
 521                      /* DOT 4 always uses the source from the color op */
 522                      result = src[0][0][0] * src[0][1][0] +
 523                         src[0][0][1] * src[0][1][1] +
 524                         src[0][0][2] * src[0][1][2] +
 525                         src[0][0][3] * src[0][1][3];
 526                      if (!optype) {
 527                         for (i = 0; i < 3; i++) {
 528                            dst[optype][i] = result;
 529                         }
 530                      }
 531                      else
 532                         dst[optype][3] = result;
 533                   }
 534                   break;
 535
 536                }
 537             }
 538          }
 539
 540          /* write out the destination registers */
 541          for (optype = 0; optype < 2; optype++) {
 542             if (inst->Opcode[optype]) {
 543                dstreg = inst->DstReg[optype].Index;
 544                dstp = machine->Registers[dstreg - GL_REG_0_ATI];
 545
 546                if ((optype == 0) || ((inst->Opcode[1] != GL_DOT2_ADD_ATI) &&
 547                   (inst->Opcode[1] != GL_DOT3_ATI) && (inst->Opcode[1] != GL_DOT4_ATI)))
 548                   write_dst_addr(optype, inst->DstReg[optype].dstMod,
 549                               inst->DstReg[optype].dstMask, dst[optype],
 550                               dstp);
 551                else
 552                   write_dst_addr(1, inst->DstReg[0].dstMod, 0, dst[1], dstp);
 553             }
 554          }
 555       }
 556    }
 557    return GL_TRUE;
 558 }
 559
 560
 561 /**
 562  * Init fragment shader virtual machine state.
 563  */
 564 static void
 565 init_machine(GLcontext * ctx, struct atifs_machine *machine,
 566              const struct ati_fragment_shader *shader,
 567              const SWspan *span, GLuint col)
 568 {
 569    GLfloat (*inputs)[4] = machine->Inputs;
 570    GLint i, j;
 571
 572    for (i = 0; i < 6; i++) {
 573       for (j = 0; j < 4; j++)
 574          machine->Registers[i][j] = 0.0;
 575    }
 576
 577    if (span->array->ChanType == GL_UNSIGNED_BYTE) {
 578       GLubyte (*rgba)[4] = span->array->color.sz1.rgba;
 579       GLubyte (*spec)[4] = span->array->color.sz1.spec;
 580       inputs[ATI_FS_INPUT_PRIMARY][0] = UBYTE_TO_FLOAT(rgba[col][0]);
 581       inputs[ATI_FS_INPUT_PRIMARY][1] = UBYTE_TO_FLOAT(rgba[col][1]);
 582       inputs[ATI_FS_INPUT_PRIMARY][2] = UBYTE_TO_FLOAT(rgba[col][2]);
 583       inputs[ATI_FS_INPUT_PRIMARY][3] = UBYTE_TO_FLOAT(rgba[col][3]);
 584       inputs[ATI_FS_INPUT_SECONDARY][0] = UBYTE_TO_FLOAT(spec[col][0]);
 585       inputs[ATI_FS_INPUT_SECONDARY][1] = UBYTE_TO_FLOAT(spec[col][1]);
 586       inputs[ATI_FS_INPUT_SECONDARY][2] = UBYTE_TO_FLOAT(spec[col][2]);
 587       inputs[ATI_FS_INPUT_SECONDARY][3] = UBYTE_TO_FLOAT(spec[col][3]);
 588   }
 589    else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
 590       GLushort (*rgba)[4] = span->array->color.sz2.rgba;
 591       GLushort (*spec)[4] = span->array->color.sz2.spec;
 592       inputs[ATI_FS_INPUT_PRIMARY][0] = USHORT_TO_FLOAT(rgba[col][0]);
 593       inputs[ATI_FS_INPUT_PRIMARY][1] = USHORT_TO_FLOAT(rgba[col][1]);
 594       inputs[ATI_FS_INPUT_PRIMARY][2] = USHORT_TO_FLOAT(rgba[col][2]);
 595       inputs[ATI_FS_INPUT_PRIMARY][3] = USHORT_TO_FLOAT(rgba[col][3]);
 596       inputs[ATI_FS_INPUT_SECONDARY][0] = USHORT_TO_FLOAT(spec[col][0]);
 597       inputs[ATI_FS_INPUT_SECONDARY][1] = USHORT_TO_FLOAT(spec[col][1]);
 598       inputs[ATI_FS_INPUT_SECONDARY][2] = USHORT_TO_FLOAT(spec[col][2]);
 599       inputs[ATI_FS_INPUT_SECONDARY][3] = USHORT_TO_FLOAT(spec[col][3]);
 600    }
 601    else {
 602       GLfloat (*rgba)[4] = span->array->color.sz4.rgba;
 603       GLfloat (*spec)[4] = span->array->color.sz4.spec;
 604       COPY_4V(inputs[ATI_FS_INPUT_PRIMARY], rgba[col]);
 605       COPY_4V(inputs[ATI_FS_INPUT_SECONDARY], spec[col]);
 606    }
 607 }
 608
 609
 610
 611 /**
 612  * Execute the current ATI shader program, operating on the given span.
 613  */
 614 void
 615 _swrast_exec_fragment_shader(GLcontext * ctx, SWspan *span)
 616 {
 617    const struct ati_fragment_shader *shader = ctx->ATIFragmentShader.Current;
 618    struct atifs_machine machine;
 619    GLuint i;
 620
 621    ctx->_CurrentProgram = GL_FRAGMENT_SHADER_ATI;
 622
 623    for (i = 0; i < span->end; i++) {
 624       if (span->array->mask[i]) {
 625          init_machine(ctx, &machine, shader, span, i);
 626          /* can't really happen... */
 627          if (!execute_shader(ctx, shader, ~0, &machine, span, i)) {
 628             span->array->mask[i] = GL_FALSE;
 629             span->writeAll = GL_FALSE;
 630          }
 631
 632          /* store result color */
 633          {
 634             const GLfloat *colOut = machine.Registers[0];
 635             /*fprintf(stderr,"outputs %f %f %f %f\n",
 636               colOut[0], colOut[1], colOut[2], colOut[3]); */
 637             if (span->array->ChanType == GL_UNSIGNED_BYTE) {
 638                GLubyte (*rgba)[4] = span->array->color.sz1.rgba;
 639                UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][RCOMP], colOut[0]);
 640                UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][GCOMP], colOut[1]);
 641                UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][BCOMP], colOut[2]);
 642                UNCLAMPED_FLOAT_TO_UBYTE(rgba[i][ACOMP], colOut[3]);
 643             }
 644             else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
 645                GLushort (*rgba)[4] = span->array->color.sz2.rgba;
 646                UNCLAMPED_FLOAT_TO_USHORT(rgba[i][RCOMP], colOut[0]);
 647                UNCLAMPED_FLOAT_TO_USHORT(rgba[i][GCOMP], colOut[1]);
 648                UNCLAMPED_FLOAT_TO_USHORT(rgba[i][BCOMP], colOut[2]);
 649                UNCLAMPED_FLOAT_TO_USHORT(rgba[i][ACOMP], colOut[3]);
 650             }
 651             else {
 652                GLfloat (*rgba)[4] = span->array->color.sz4.rgba;
 653                COPY_4V(rgba[i], colOut);
 654             }
 655          }
 656       }
 657    }
 658
 659    ctx->_CurrentProgram = 0;
 660 }