src/mesa/swrast/s_atifragshader.c

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