src/Shader/PixelRoutine.cpp

   1 // SwiftShader Software Renderer
   2 //
   3 // Copyright(c) 2005-2013 TransGaming Inc.
   4 //
   5 // All rights reserved. No part of this software may be copied, distributed, transmitted,
   6 // transcribed, stored in a retrieval system, translated into any human or computer
   7 // language by any means, or disclosed to third parties without the explicit written
   8 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
   9 // or implied, including but not limited to any patent rights, are granted to you.
  10 //
  11
  12 #include "PixelRoutine.hpp"
  13
  14 #include "Renderer.hpp"
  15 #include "QuadRasterizer.hpp"
  16 #include "Surface.hpp"
  17 #include "Primitive.hpp"
  18 #include "CPUID.hpp"
  19 #include "SamplerCore.hpp"
  20 #include "Constants.hpp"
  21 #include "Debug.hpp"
  22
  23 extern bool localShaderConstants;
  24
  25 namespace sw
  26 {
  27         extern bool complementaryDepthBuffer;
  28         extern bool postBlendSRGB;
  29         extern bool exactColorRounding;
  30         extern bool booleanFaceRegister;
  31         extern bool halfIntegerCoordinates;     // Pixel centers are not at integer coordinates
  32         extern bool fullPixelPositionRegister;
  33
  34         PixelRoutine::PixelRoutine(const PixelProcessor::State &state, const PixelShader *shader) : Rasterizer(state), shader(shader)
  35         {
  36                 perturbate = false;
  37                 luminance = false;
  38                 previousScaling = false;
  39
  40                 ifDepth = 0;
  41                 loopRepDepth = 0;
  42                 breakDepth = 0;
  43                 currentLabel = -1;
  44                 whileTest = false;
  45
  46                 for(int i = 0; i < 2048; i++)
  47                 {
  48                         labelBlock[i] = 0;
  49                 }
  50         }
  51
  52         PixelRoutine::~PixelRoutine()
  53         {
  54                 for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
  55                 {
  56                         delete sampler[i];
  57                 }
  58         }
  59
  60         void PixelRoutine::quad(Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y)
  61         {
  62                 #if PERF_PROFILE
  63                         Long pipeTime = Ticks();
  64                 #endif
  65
  66                 for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
  67                 {
  68                         sampler[i] = new SamplerCore(r.constants, state.sampler[i]);
  69                 }
  70
  71                 const bool earlyDepthTest = !state.depthOverride && !state.alphaTestActive();
  72                 const bool integerPipeline = shaderVersion() <= 0x0104;
  73
  74                 Int zMask[4];   // Depth mask
  75                 Int sMask[4];   // Stencil mask
  76
  77                 for(unsigned int q = 0; q < state.multiSample; q++)
  78                 {
  79                         zMask[q] = cMask[q];
  80                         sMask[q] = cMask[q];
  81                 }
  82
  83                 for(unsigned int q = 0; q < state.multiSample; q++)
  84                 {
  85                         stencilTest(r, sBuffer, q, x, sMask[q], cMask[q]);
  86                 }
  87
  88                 Float4 f;
  89
  90                 Float4 (&z)[4] = r.z;
  91                 Float4 &w = r.w;
  92                 Float4 &rhw = r.rhw;
  93                 Float4 rhwCentroid;
  94
  95                 Float4 xxxx = Float4(Float(x)) + *Pointer<Float4>(r.primitive + OFFSET(Primitive,xQuad), 16);
  96
  97                 if(interpolateZ())
  98                 {
  99                         for(unsigned int q = 0; q < state.multiSample; q++)
 100                         {
 101                                 Float4 x = xxxx;
 102
 103                                 if(state.multiSample > 1)
 104                                 {
 105                                         x -= *Pointer<Float4>(r.constants + OFFSET(Constants,X) + q * sizeof(float4));
 106                                 }
 107
 108                                 z[q] = interpolate(x, r.Dz[q], z[q], r.primitive + OFFSET(Primitive,z), false, false);
 109                         }
 110                 }
 111
 112                 Bool depthPass = false;
 113
 114                 if(earlyDepthTest)
 115                 {
 116                         for(unsigned int q = 0; q < state.multiSample; q++)
 117                         {
 118                                 depthPass = depthPass || depthTest(r, zBuffer, q, x, z[q], sMask[q], zMask[q], cMask[q]);
 119                         }
 120                 }
 121
 122                 If(depthPass || Bool(!earlyDepthTest))
 123                 {
 124                         #if PERF_PROFILE
 125                                 Long interpTime = Ticks();
 126                         #endif
 127
 128                         Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(r.primitive + OFFSET(Primitive,yQuad), 16);
 129
 130                         // Centroid locations
 131                         Float4 XXXX = Float4(0.0f);
 132                         Float4 YYYY = Float4(0.0f);
 133
 134                         if(state.centroid)
 135                         {
 136                                 Float4 WWWW(1.0e-9f);
 137
 138                                 for(unsigned int q = 0; q < state.multiSample; q++)
 139                                 {
 140                                         XXXX += *Pointer<Float4>(r.constants + OFFSET(Constants,sampleX[q]) + 16 * cMask[q]);
 141                                         YYYY += *Pointer<Float4>(r.constants + OFFSET(Constants,sampleY[q]) + 16 * cMask[q]);
 142                                         WWWW += *Pointer<Float4>(r.constants + OFFSET(Constants,weight) + 16 * cMask[q]);
 143                                 }
 144
 145                                 WWWW = Rcp_pp(WWWW);
 146                                 XXXX *= WWWW;
 147                                 YYYY *= WWWW;
 148
 149                                 XXXX += xxxx;
 150                                 YYYY += yyyy;
 151                         }
 152
 153                         if(interpolateW())
 154                         {
 155                                 w = interpolate(xxxx, r.Dw, rhw, r.primitive + OFFSET(Primitive,w), false, false);
 156                                 rhw = reciprocal(w);
 157
 158                                 if(state.centroid)
 159                                 {
 160                                         rhwCentroid = reciprocal(interpolateCentroid(XXXX, YYYY, rhwCentroid, r.primitive + OFFSET(Primitive,w), false, false));
 161                                 }
 162                         }
 163
 164                         for(int interpolant = 0; interpolant < 10; interpolant++)
 165                         {
 166                                 for(int component = 0; component < 4; component++)
 167                                 {
 168                                         if(state.interpolant[interpolant].component & (1 << component))
 169                                         {
 170                                                 if(!state.interpolant[interpolant].centroid)
 171                                                 {
 172                                                         r.vf[interpolant][component] = interpolate(xxxx, r.Dv[interpolant][component], rhw, r.primitive + OFFSET(Primitive,V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective);
 173                                                 }
 174                                                 else
 175                                                 {
 176                                                         r.vf[interpolant][component] = interpolateCentroid(XXXX, YYYY, rhwCentroid, r.primitive + OFFSET(Primitive,V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective);
 177                                                 }
 178                                         }
 179                                 }
 180
 181                                 Float4 rcp;
 182
 183                                 switch(state.interpolant[interpolant].project)
 184                                 {
 185                                 case 0:
 186                                         break;
 187                                 case 1:
 188                                         rcp = reciprocal(r.vf[interpolant].y);
 189                                         r.vf[interpolant].x = r.vf[interpolant].x * rcp;
 190                                         break;
 191                                 case 2:
 192                                         rcp = reciprocal(r.vf[interpolant].z);
 193                                         r.vf[interpolant].x = r.vf[interpolant].x * rcp;
 194                                         r.vf[interpolant].y = r.vf[interpolant].y * rcp;
 195                                         break;
 196                                 case 3:
 197                                         rcp = reciprocal(r.vf[interpolant].w);
 198                                         r.vf[interpolant].x = r.vf[interpolant].x * rcp;
 199                                         r.vf[interpolant].y = r.vf[interpolant].y * rcp;
 200                                         r.vf[interpolant].z = r.vf[interpolant].z * rcp;
 201                                         break;
 202                                 }
 203                         }
 204
 205                         if(state.fog.component)
 206                         {
 207                                 f = interpolate(xxxx, r.Df, rhw, r.primitive + OFFSET(Primitive,f), state.fog.flat & 0x01, state.perspective);
 208                         }
 209
 210                         if(integerPipeline)
 211                         {
 212                                 if(state.color[0].component & 0x1) r.diffuse.x = convertFixed12(r.vf[0].x); else r.diffuse.x = Short4(0x1000);
 213                                 if(state.color[0].component & 0x2) r.diffuse.y = convertFixed12(r.vf[0].y); else r.diffuse.y = Short4(0x1000);
 214                                 if(state.color[0].component & 0x4) r.diffuse.z = convertFixed12(r.vf[0].z); else r.diffuse.z = Short4(0x1000);
 215                                 if(state.color[0].component & 0x8) r.diffuse.w = convertFixed12(r.vf[0].w); else r.diffuse.w = Short4(0x1000);
 216
 217                                 if(state.color[1].component & 0x1) r.specular.x = convertFixed12(r.vf[1].x); else r.specular.x = Short4(0x0000, 0x0000, 0x0000, 0x0000);
 218                                 if(state.color[1].component & 0x2) r.specular.y = convertFixed12(r.vf[1].y); else r.specular.y = Short4(0x0000, 0x0000, 0x0000, 0x0000);
 219                                 if(state.color[1].component & 0x4) r.specular.z = convertFixed12(r.vf[1].z); else r.specular.z = Short4(0x0000, 0x0000, 0x0000, 0x0000);
 220                                 if(state.color[1].component & 0x8) r.specular.w = convertFixed12(r.vf[1].w); else r.specular.w = Short4(0x0000, 0x0000, 0x0000, 0x0000);
 221                         }
 222                         else if(shaderVersion() >= 0x0300)
 223                         {
 224                                 if(shader->vPosDeclared)
 225                                 {
 226                                         if(!halfIntegerCoordinates)
 227                                         {
 228                                                 r.vPos.x = Float4(Float(x)) + Float4(0, 1, 0, 1);
 229                                                 r.vPos.y = Float4(Float(y)) + Float4(0, 0, 1, 1);
 230                                         }
 231                                         else
 232                                         {
 233                                                 r.vPos.x = Float4(Float(x)) + Float4(0.5f, 1.5f, 0.5f, 1.5f);
 234                                                 r.vPos.y = Float4(Float(y)) + Float4(0.5f, 0.5f, 1.5f, 1.5f);
 235                                         }
 236
 237                                         if(fullPixelPositionRegister)
 238                                         {
 239                                                 r.vPos.z = z[0];   // FIXME: Centroid?
 240                                                 r.vPos.w = w;      // FIXME: Centroid?
 241                                         }
 242                                 }
 243
 244                                 if(shader->vFaceDeclared)
 245                                 {
 246                                         Float4 area = *Pointer<Float>(r.primitive + OFFSET(Primitive,area));
 247                                         Float4 face = booleanFaceRegister ? Float4(As<Float4>(CmpNLT(area, Float4(0.0f)))) : area;
 248
 249                                         r.vFace.x = face;
 250                                         r.vFace.y = face;
 251                                         r.vFace.z = face;
 252                                         r.vFace.w = face;
 253                                 }
 254                         }
 255
 256                         #if PERF_PROFILE
 257                                 r.cycles[PERF_INTERP] += Ticks() - interpTime;
 258                         #endif
 259
 260                         Bool alphaPass = true;
 261
 262                         if(colorUsed())
 263                         {
 264                                 #if PERF_PROFILE
 265                                         Long shaderTime = Ticks();
 266                                 #endif
 267
 268                                 if(shader)
 269                                 {
 270                                 //      shader->print("PixelShader-%0.8X.txt", state.shaderID);
 271
 272                                         if(shader->getVersion() <= 0x0104)
 273                                         {
 274                                                 ps_1_x(r, cMask);
 275                                         }
 276                                         else
 277                                         {
 278                                                 ps_2_x(r, cMask);
 279                                         }
 280                                 }
 281                                 else
 282                                 {
 283                                         r.current = r.diffuse;
 284                                         Vector4s temp(0x0000, 0x0000, 0x0000, 0x0000);
 285
 286                                         for(int stage = 0; stage < 8; stage++)
 287                                         {
 288                                                 if(state.textureStage[stage].stageOperation == TextureStage::STAGE_DISABLE)
 289                                                 {
 290                                                         break;
 291                                                 }
 292
 293                                                 Vector4s texture;
 294
 295                                                 if(state.textureStage[stage].usesTexture)
 296                                                 {
 297                                                         sampleTexture(r, texture, stage, stage);
 298                                                 }
 299
 300                                                 blendTexture(r, temp, texture, stage);
 301                                         }
 302
 303                                         specularPixel(r.current, r.specular);
 304                                 }
 305
 306                                 #if PERF_PROFILE
 307                                         r.cycles[PERF_SHADER] += Ticks() - shaderTime;
 308                                 #endif
 309
 310                                 if(integerPipeline)
 311                                 {
 312                                         r.current.x = Min(r.current.x, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.x = Max(r.current.x, Short4(0x0000, 0x0000, 0x0000, 0x0000));
 313                                         r.current.y = Min(r.current.y, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.y = Max(r.current.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));
 314                                         r.current.z = Min(r.current.z, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.z = Max(r.current.z, Short4(0x0000, 0x0000, 0x0000, 0x0000));
 315                                         r.current.w = Min(r.current.w, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.w = Max(r.current.w, Short4(0x0000, 0x0000, 0x0000, 0x0000));
 316
 317                                         alphaPass = alphaTest(r, cMask, r.current);
 318                                 }
 319                                 else
 320                                 {
 321                                         clampColor(r.oC);
 322
 323                                         alphaPass = alphaTest(r, cMask, r.oC[0]);
 324                                 }
 325
 326                                 if((shader && shader->containsKill()) || state.alphaTestActive())
 327                                 {
 328                                         for(unsigned int q = 0; q < state.multiSample; q++)
 329                                         {
 330                                                 zMask[q] &= cMask[q];
 331                                                 sMask[q] &= cMask[q];
 332                                         }
 333                                 }
 334                         }
 335
 336                         If(alphaPass)
 337                         {
 338                                 if(!earlyDepthTest)
 339                                 {
 340                                         for(unsigned int q = 0; q < state.multiSample; q++)
 341                                         {
 342                                                 depthPass = depthPass || depthTest(r, zBuffer, q, x, z[q], sMask[q], zMask[q], cMask[q]);
 343                                         }
 344                                 }
 345
 346                                 #if PERF_PROFILE
 347                                         Long ropTime = Ticks();
 348                                 #endif
 349
 350                                 If(depthPass || Bool(earlyDepthTest))
 351                                 {
 352                                         for(unsigned int q = 0; q < state.multiSample; q++)
 353                                         {
 354                                                 if(state.multiSampleMask & (1 << q))
 355                                                 {
 356                                                         writeDepth(r, zBuffer, q, x, z[q], zMask[q]);
 357
 358                                                         if(state.occlusionEnabled)
 359                                                         {
 360                                                                 r.occlusion += *Pointer<UInt>(r.constants + OFFSET(Constants,occlusionCount) + 4 * (zMask[q] & sMask[q]));
 361                                                         }
 362                                                 }
 363                                         }
 364
 365                                         if(colorUsed())
 366                                         {
 367                                                 #if PERF_PROFILE
 368                                                         AddAtomic(Pointer<Long>(&profiler.ropOperations), 4);
 369                                                 #endif
 370
 371                                                 if(integerPipeline)
 372                                                 {
 373                                                         rasterOperation(r.current, r, f, cBuffer[0], x, sMask, zMask, cMask);
 374                                                 }
 375                                                 else
 376                                                 {
 377                                                         rasterOperation(r.oC, r, f, cBuffer, x, sMask, zMask, cMask);
 378                                                 }
 379                                         }
 380                                 }
 381
 382                                 #if PERF_PROFILE
 383                                         r.cycles[PERF_ROP] += Ticks() - ropTime;
 384                                 #endif
 385                         }
 386                 }
 387
 388                 for(unsigned int q = 0; q < state.multiSample; q++)
 389                 {
 390                         if(state.multiSampleMask & (1 << q))
 391                         {
 392                                 writeStencil(r, sBuffer, q, x, sMask[q], zMask[q], cMask[q]);
 393                         }
 394                 }
 395
 396                 #if PERF_PROFILE
 397                         r.cycles[PERF_PIPE] += Ticks() - pipeTime;
 398                 #endif
 399         }
 400
 401         Float4 PixelRoutine::interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
 402         {
 403                 Float4 interpolant = D;
 404
 405                 if(!flat)
 406                 {
 407                         interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,A), 16);
 408
 409                         if(perspective)
 410                         {
 411                                 interpolant *= rhw;
 412                         }
 413                 }
 414
 415                 return interpolant;
 416         }
 417
 418         Float4 PixelRoutine::interpolateCentroid(Float4 &x, Float4 &y, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
 419         {
 420                 Float4 interpolant = *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,C), 16);
 421
 422                 if(!flat)
 423                 {
 424                         interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,A), 16) +
 425                                        y * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,B), 16);
 426
 427                         if(perspective)
 428                         {
 429                                 interpolant *= rhw;
 430                         }
 431                 }
 432
 433                 return interpolant;
 434         }
 435
 436         void PixelRoutine::stencilTest(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask)
 437         {
 438                 if(!state.stencilActive)
 439                 {
 440                         return;
 441                 }
 442
 443                 // (StencilRef & StencilMask) CompFunc (StencilBufferValue & StencilMask)
 444
 445                 Pointer<Byte> buffer = sBuffer + 2 * x;
 446
 447                 if(q > 0)
 448                 {
 449                         buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,stencilSliceB));
 450                 }
 451
 452                 Byte8 value = As<Byte8>(Long1(*Pointer<UInt>(buffer)));
 453                 Byte8 valueCCW = value;
 454
 455                 if(!state.noStencilMask)
 456                 {
 457                         value &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[0].testMaskQ));
 458                 }
 459
 460                 stencilTest(r, value, state.stencilCompareMode, false);
 461
 462                 if(state.twoSidedStencil)
 463                 {
 464                         if(!state.noStencilMaskCCW)
 465                         {
 466                                 valueCCW &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[1].testMaskQ));
 467                         }
 468
 469                         stencilTest(r, valueCCW, state.stencilCompareModeCCW, true);
 470
 471                         value &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,clockwiseMask));
 472                         valueCCW &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,invClockwiseMask));
 473                         value |= valueCCW;
 474                 }
 475
 476                 sMask = SignMask(value) & cMask;
 477         }
 478
 479         void PixelRoutine::stencilTest(Registers &r, Byte8 &value, StencilCompareMode stencilCompareMode, bool CCW)
 480         {
 481                 Byte8 equal;
 482
 483                 switch(stencilCompareMode)
 484                 {
 485                 case STENCIL_ALWAYS:
 486                         value = Byte8(0xFFFFFFFFFFFFFFFF);
 487                         break;
 488                 case STENCIL_NEVER:
 489                         value = Byte8(0x0000000000000000);
 490                         break;
 491                 case STENCIL_LESS:                      // a < b ~ b > a
 492                         value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
 493                         value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
 494                         break;
 495                 case STENCIL_EQUAL:
 496                         value = CmpEQ(value, *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
 497                         break;
 498                 case STENCIL_NOTEQUAL:          // a != b ~ !(a == b)
 499                         value = CmpEQ(value, *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
 500                         value ^= Byte8(0xFFFFFFFFFFFFFFFF);
 501                         break;
 502                 case STENCIL_LESSEQUAL: // a <= b ~ (b > a) || (a == b)
 503                         equal = value;
 504                         equal = CmpEQ(equal, *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
 505                         value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
 506                         value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
 507                         value |= equal;
 508                         break;
 509                 case STENCIL_GREATER:           // a > b
 510                         equal = *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ));
 511                         value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
 512                         equal = CmpGT(As<SByte8>(equal), As<SByte8>(value));
 513                         value = equal;
 514                         break;
 515                 case STENCIL_GREATEREQUAL:      // a >= b ~ !(a < b) ~ !(b > a)
 516                         value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
 517                         value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
 518                         value ^= Byte8(0xFFFFFFFFFFFFFFFF);
 519                         break;
 520                 default:
 521                         ASSERT(false);
 522                 }
 523         }
 524
 525         Bool PixelRoutine::depthTest(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask)
 526         {
 527                 if(!state.depthTestActive)
 528                 {
 529                         return true;
 530                 }
 531
 532                 Float4 Z = z;
 533
 534                 if(shader && shader->depthOverride())
 535                 {
 536                         if(complementaryDepthBuffer)
 537                         {
 538                                 Z = Float4(1.0f) - r.oDepth;
 539                         }
 540                         else
 541                         {
 542                                 Z = r.oDepth;
 543                         }
 544                 }
 545
 546                 Pointer<Byte> buffer;
 547                 Int pitch;
 548
 549                 if(!state.quadLayoutDepthBuffer)
 550                 {
 551                         buffer = zBuffer + 4 * x;
 552                         pitch = *Pointer<Int>(r.data + OFFSET(DrawData,depthPitchB));
 553                 }
 554                 else
 555                 {
 556                         buffer = zBuffer + 8 * x;
 557                 }
 558
 559                 if(q > 0)
 560                 {
 561                         buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,depthSliceB));
 562                 }
 563
 564                 Float4 zValue;
 565
 566                 if(state.depthCompareMode != DEPTH_NEVER || (state.depthCompareMode != DEPTH_ALWAYS && !state.depthWriteEnable))
 567                 {
 568                         if(!state.quadLayoutDepthBuffer)
 569                         {
 570                                 // FIXME: Properly optimizes?
 571                                 zValue.xy = *Pointer<Float4>(buffer);
 572                                 zValue.zw = *Pointer<Float4>(buffer + pitch - 8);
 573                         }
 574                         else
 575                         {
 576                                 zValue = *Pointer<Float4>(buffer, 16);
 577                         }
 578                 }
 579
 580                 Int4 zTest;
 581
 582                 switch(state.depthCompareMode)
 583                 {
 584                 case DEPTH_ALWAYS:
 585                         // Optimized
 586                         break;
 587                 case DEPTH_NEVER:
 588                         // Optimized
 589                         break;
 590                 case DEPTH_EQUAL:
 591                         zTest = CmpEQ(zValue, Z);
 592                         break;
 593                 case DEPTH_NOTEQUAL:
 594                         zTest = CmpNEQ(zValue, Z);
 595                         break;
 596                 case DEPTH_LESS:
 597                         if(complementaryDepthBuffer)
 598                         {
 599                                 zTest = CmpLT(zValue, Z);
 600                         }
 601                         else
 602                         {
 603                                 zTest = CmpNLE(zValue, Z);
 604                         }
 605                         break;
 606                 case DEPTH_GREATEREQUAL:
 607                         if(complementaryDepthBuffer)
 608                         {
 609                                 zTest = CmpNLT(zValue, Z);
 610                         }
 611                         else
 612                         {
 613                                 zTest = CmpLE(zValue, Z);
 614                         }
 615                         break;
 616                 case DEPTH_LESSEQUAL:
 617                         if(complementaryDepthBuffer)
 618                         {
 619                                 zTest = CmpLE(zValue, Z);
 620                         }
 621                         else
 622                         {
 623                                 zTest = CmpNLT(zValue, Z);
 624                         }
 625                         break;
 626                 case DEPTH_GREATER:
 627                         if(complementaryDepthBuffer)
 628                         {
 629                                 zTest = CmpNLE(zValue, Z);
 630                         }
 631                         else
 632                         {
 633                                 zTest = CmpLT(zValue, Z);
 634                         }
 635                         break;
 636                 default:
 637                         ASSERT(false);
 638                 }
 639
 640                 switch(state.depthCompareMode)
 641                 {
 642                 case DEPTH_ALWAYS:
 643                         zMask = cMask;
 644                         break;
 645                 case DEPTH_NEVER:
 646                         zMask = 0x0;
 647                         break;
 648                 default:
 649                         zMask = SignMask(zTest) & cMask;
 650                         break;
 651                 }
 652
 653                 if(state.stencilActive)
 654                 {
 655                         zMask &= sMask;
 656                 }
 657
 658                 return zMask != 0;
 659         }
 660
 661         void PixelRoutine::blendTexture(Registers &r, Vector4s &temp, Vector4s &texture, int stage)
 662         {
 663                 Vector4s *arg1;
 664                 Vector4s *arg2;
 665                 Vector4s *arg3;
 666                 Vector4s res;
 667
 668                 Vector4s constant;
 669                 Vector4s tfactor;
 670
 671                 const TextureStage::State &textureStage = state.textureStage[stage];
 672
 673                 if(textureStage.firstArgument == TextureStage::SOURCE_CONSTANT ||
 674                    textureStage.firstArgumentAlpha == TextureStage::SOURCE_CONSTANT ||
 675                    textureStage.secondArgument == TextureStage::SOURCE_CONSTANT ||
 676                    textureStage.secondArgumentAlpha == TextureStage::SOURCE_CONSTANT ||
 677                    textureStage.thirdArgument == TextureStage::SOURCE_CONSTANT ||
 678                    textureStage.thirdArgumentAlpha == TextureStage::SOURCE_CONSTANT)
 679                 {
 680                         constant.x = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[0]));
 681                         constant.y = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[1]));
 682                         constant.z = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[2]));
 683                         constant.w = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[3]));
 684                 }
 685
 686                 if(textureStage.firstArgument == TextureStage::SOURCE_TFACTOR ||
 687                    textureStage.firstArgumentAlpha == TextureStage::SOURCE_TFACTOR ||
 688                    textureStage.secondArgument == TextureStage::SOURCE_TFACTOR ||
 689                    textureStage.secondArgumentAlpha == TextureStage::SOURCE_TFACTOR ||
 690                    textureStage.thirdArgument == TextureStage::SOURCE_TFACTOR ||
 691                    textureStage.thirdArgumentAlpha == TextureStage::SOURCE_TFACTOR)
 692                 {
 693                         tfactor.x = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[0]));
 694                         tfactor.y = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[1]));
 695                         tfactor.z = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[2]));
 696                         tfactor.w = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]));
 697                 }
 698
 699                 // Premodulate
 700                 if(stage > 0 && textureStage.usesTexture)
 701                 {
 702                         if(state.textureStage[stage - 1].stageOperation == TextureStage::STAGE_PREMODULATE)
 703                         {
 704                                 r.current.x = MulHigh(r.current.x, texture.x) << 4;
 705                                 r.current.y = MulHigh(r.current.y, texture.y) << 4;
 706                                 r.current.z = MulHigh(r.current.z, texture.z) << 4;
 707                         }
 708
 709                         if(state.textureStage[stage - 1].stageOperationAlpha == TextureStage::STAGE_PREMODULATE)
 710                         {
 711                                 r.current.w = MulHigh(r.current.w, texture.w) << 4;
 712                         }
 713                 }
 714
 715                 if(luminance)
 716                 {
 717                         texture.x = MulHigh(texture.x, r.L) << 4;
 718                         texture.y = MulHigh(texture.y, r.L) << 4;
 719                         texture.z = MulHigh(texture.z, r.L) << 4;
 720
 721                         luminance = false;
 722                 }
 723
 724                 switch(textureStage.firstArgument)
 725                 {
 726                 case TextureStage::SOURCE_TEXTURE:      arg1 = &texture;                break;
 727                 case TextureStage::SOURCE_CONSTANT:     arg1 = &constant;               break;
 728                 case TextureStage::SOURCE_CURRENT:      arg1 = &r.current;              break;
 729                 case TextureStage::SOURCE_DIFFUSE:      arg1 = &r.diffuse;              break;
 730                 case TextureStage::SOURCE_SPECULAR:     arg1 = &r.specular;             break;
 731                 case TextureStage::SOURCE_TEMP:         arg1 = &temp;                   break;
 732                 case TextureStage::SOURCE_TFACTOR:      arg1 = &tfactor;                break;
 733                 default:
 734                         ASSERT(false);
 735                 }
 736
 737                 switch(textureStage.secondArgument)
 738                 {
 739                 case TextureStage::SOURCE_TEXTURE:      arg2 = &texture;                break;
 740                 case TextureStage::SOURCE_CONSTANT:     arg2 = &constant;               break;
 741                 case TextureStage::SOURCE_CURRENT:      arg2 = &r.current;              break;
 742                 case TextureStage::SOURCE_DIFFUSE:      arg2 = &r.diffuse;              break;
 743                 case TextureStage::SOURCE_SPECULAR:     arg2 = &r.specular;             break;
 744                 case TextureStage::SOURCE_TEMP:         arg2 = &temp;                   break;
 745                 case TextureStage::SOURCE_TFACTOR:      arg2 = &tfactor;                break;
 746                 default:
 747                         ASSERT(false);
 748                 }
 749
 750                 switch(textureStage.thirdArgument)
 751                 {
 752                 case TextureStage::SOURCE_TEXTURE:      arg3 = &texture;                break;
 753                 case TextureStage::SOURCE_CONSTANT:     arg3 = &constant;               break;
 754                 case TextureStage::SOURCE_CURRENT:      arg3 = &r.current;              break;
 755                 case TextureStage::SOURCE_DIFFUSE:      arg3 = &r.diffuse;              break;
 756                 case TextureStage::SOURCE_SPECULAR:     arg3 = &r.specular;             break;
 757                 case TextureStage::SOURCE_TEMP:         arg3 = &temp;                   break;
 758                 case TextureStage::SOURCE_TFACTOR:      arg3 = &tfactor;                break;
 759                 default:
 760                         ASSERT(false);
 761                 }
 762
 763                 Vector4s mod1;
 764                 Vector4s mod2;
 765                 Vector4s mod3;
 766
 767                 switch(textureStage.firstModifier)
 768                 {
 769                 case TextureStage::MODIFIER_COLOR:
 770                         break;
 771                 case TextureStage::MODIFIER_INVCOLOR:
 772                         {
 773                                 mod1.x = SubSat(Short4(0x1000), arg1->x);
 774                                 mod1.y = SubSat(Short4(0x1000), arg1->y);
 775                                 mod1.z = SubSat(Short4(0x1000), arg1->z);
 776                                 mod1.w = SubSat(Short4(0x1000), arg1->w);
 777
 778                                 arg1 = &mod1;
 779                         }
 780                         break;
 781                 case TextureStage::MODIFIER_ALPHA:
 782                         {
 783                                 mod1.x = arg1->w;
 784                                 mod1.y = arg1->w;
 785                                 mod1.z = arg1->w;
 786                                 mod1.w = arg1->w;
 787
 788                                 arg1 = &mod1;
 789                         }
 790                         break;
 791                 case TextureStage::MODIFIER_INVALPHA:
 792                         {
 793                                 mod1.x = SubSat(Short4(0x1000), arg1->w);
 794                                 mod1.y = SubSat(Short4(0x1000), arg1->w);
 795                                 mod1.z = SubSat(Short4(0x1000), arg1->w);
 796                                 mod1.w = SubSat(Short4(0x1000), arg1->w);
 797
 798                                 arg1 = &mod1;
 799                         }
 800                         break;
 801                 default:
 802                         ASSERT(false);
 803                 }
 804
 805                 switch(textureStage.secondModifier)
 806                 {
 807                 case TextureStage::MODIFIER_COLOR:
 808                         break;
 809                 case TextureStage::MODIFIER_INVCOLOR:
 810                         {
 811                                 mod2.x = SubSat(Short4(0x1000), arg2->x);
 812                                 mod2.y = SubSat(Short4(0x1000), arg2->y);
 813                                 mod2.z = SubSat(Short4(0x1000), arg2->z);
 814                                 mod2.w = SubSat(Short4(0x1000), arg2->w);
 815
 816                                 arg2 = &mod2;
 817                         }
 818                         break;
 819                 case TextureStage::MODIFIER_ALPHA:
 820                         {
 821                                 mod2.x = arg2->w;
 822                                 mod2.y = arg2->w;
 823                                 mod2.z = arg2->w;
 824                                 mod2.w = arg2->w;
 825
 826                                 arg2 = &mod2;
 827                         }
 828                         break;
 829                 case TextureStage::MODIFIER_INVALPHA:
 830                         {
 831                                 mod2.x = SubSat(Short4(0x1000), arg2->w);
 832                                 mod2.y = SubSat(Short4(0x1000), arg2->w);
 833                                 mod2.z = SubSat(Short4(0x1000), arg2->w);
 834                                 mod2.w = SubSat(Short4(0x1000), arg2->w);
 835
 836                                 arg2 = &mod2;
 837                         }
 838                         break;
 839                 default:
 840                         ASSERT(false);
 841                 }
 842
 843                 switch(textureStage.thirdModifier)
 844                 {
 845                 case TextureStage::MODIFIER_COLOR:
 846                         break;
 847                 case TextureStage::MODIFIER_INVCOLOR:
 848                         {
 849                                 mod3.x = SubSat(Short4(0x1000), arg3->x);
 850                                 mod3.y = SubSat(Short4(0x1000), arg3->y);
 851                                 mod3.z = SubSat(Short4(0x1000), arg3->z);
 852                                 mod3.w = SubSat(Short4(0x1000), arg3->w);
 853
 854                                 arg3 = &mod3;
 855                         }
 856                         break;
 857                 case TextureStage::MODIFIER_ALPHA:
 858                         {
 859                                 mod3.x = arg3->w;
 860                                 mod3.y = arg3->w;
 861                                 mod3.z = arg3->w;
 862                                 mod3.w = arg3->w;
 863
 864                                 arg3 = &mod3;
 865                         }
 866                         break;
 867                 case TextureStage::MODIFIER_INVALPHA:
 868                         {
 869                                 mod3.x = SubSat(Short4(0x1000), arg3->w);
 870                                 mod3.y = SubSat(Short4(0x1000), arg3->w);
 871                                 mod3.z = SubSat(Short4(0x1000), arg3->w);
 872                                 mod3.w = SubSat(Short4(0x1000), arg3->w);
 873
 874                                 arg3 = &mod3;
 875                         }
 876                         break;
 877                 default:
 878                         ASSERT(false);
 879                 }
 880
 881                 switch(textureStage.stageOperation)
 882                 {
 883                 case TextureStage::STAGE_DISABLE:
 884                         break;
 885                 case TextureStage::STAGE_SELECTARG1:                                    // Arg1
 886                         {
 887                                 res.x = arg1->x;
 888                                 res.y = arg1->y;
 889                                 res.z = arg1->z;
 890                         }
 891                         break;
 892                 case TextureStage::STAGE_SELECTARG2:                                    // Arg2
 893                         {
 894                                 res.x = arg2->x;
 895                                 res.y = arg2->y;
 896                                 res.z = arg2->z;
 897                         }
 898                         break;
 899                 case TextureStage::STAGE_SELECTARG3:                                    // Arg3
 900                         {
 901                                 res.x = arg3->x;
 902                                 res.y = arg3->y;
 903                                 res.z = arg3->z;
 904                         }
 905                         break;
 906                 case TextureStage::STAGE_MODULATE:                                      // Arg1 * Arg2
 907                         {
 908                                 res.x = MulHigh(arg1->x, arg2->x) << 4;
 909                                 res.y = MulHigh(arg1->y, arg2->y) << 4;
 910                                 res.z = MulHigh(arg1->z, arg2->z) << 4;
 911                         }
 912                         break;
 913                 case TextureStage::STAGE_MODULATE2X:                                    // Arg1 * Arg2 * 2
 914                         {
 915                                 res.x = MulHigh(arg1->x, arg2->x) << 5;
 916                                 res.y = MulHigh(arg1->y, arg2->y) << 5;
 917                                 res.z = MulHigh(arg1->z, arg2->z) << 5;
 918                         }
 919                         break;
 920                 case TextureStage::STAGE_MODULATE4X:                                    // Arg1 * Arg2 * 4
 921                         {
 922                                 res.x = MulHigh(arg1->x, arg2->x) << 6;
 923                                 res.y = MulHigh(arg1->y, arg2->y) << 6;
 924                                 res.z = MulHigh(arg1->z, arg2->z) << 6;
 925                         }
 926                         break;
 927                 case TextureStage::STAGE_ADD:                                           // Arg1 + Arg2
 928                         {
 929                                 res.x = AddSat(arg1->x, arg2->x);
 930                                 res.y = AddSat(arg1->y, arg2->y);
 931                                 res.z = AddSat(arg1->z, arg2->z);
 932                         }
 933                         break;
 934                 case TextureStage::STAGE_ADDSIGNED:                                     // Arg1 + Arg2 - 0.5
 935                         {
 936                                 res.x = AddSat(arg1->x, arg2->x);
 937                                 res.y = AddSat(arg1->y, arg2->y);
 938                                 res.z = AddSat(arg1->z, arg2->z);
 939
 940                                 res.x = SubSat(res.x, Short4(0x0800, 0x0800, 0x0800, 0x0800));
 941                                 res.y = SubSat(res.y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
 942                                 res.z = SubSat(res.z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
 943                         }
 944                         break;
 945                 case TextureStage::STAGE_ADDSIGNED2X:                           // (Arg1 + Arg2 - 0.5) << 1
 946                         {
 947                                 res.x = AddSat(arg1->x, arg2->x);
 948                                 res.y = AddSat(arg1->y, arg2->y);
 949                                 res.z = AddSat(arg1->z, arg2->z);
 950
 951                                 res.x = SubSat(res.x, Short4(0x0800, 0x0800, 0x0800, 0x0800));
 952                                 res.y = SubSat(res.y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
 953                                 res.z = SubSat(res.z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
 954
 955                                 res.x = AddSat(res.x, res.x);
 956                                 res.y = AddSat(res.y, res.y);
 957                                 res.z = AddSat(res.z, res.z);
 958                         }
 959                         break;
 960                 case TextureStage::STAGE_SUBTRACT:                                      // Arg1 - Arg2
 961                         {
 962                                 res.x = SubSat(arg1->x, arg2->x);
 963                                 res.y = SubSat(arg1->y, arg2->y);
 964                                 res.z = SubSat(arg1->z, arg2->z);
 965                         }
 966                         break;
 967                 case TextureStage::STAGE_ADDSMOOTH:                                     // Arg1 + Arg2 - Arg1 * Arg2
 968                         {
 969                                 Short4 tmp;
 970
 971                                 tmp = MulHigh(arg1->x, arg2->x) << 4; res.x = AddSat(arg1->x, arg2->x); res.x = SubSat(res.x, tmp);
 972                                 tmp = MulHigh(arg1->y, arg2->y) << 4; res.y = AddSat(arg1->y, arg2->y); res.y = SubSat(res.y, tmp);
 973                                 tmp = MulHigh(arg1->z, arg2->z) << 4; res.z = AddSat(arg1->z, arg2->z); res.z = SubSat(res.z, tmp);
 974                         }
 975                         break;
 976                 case TextureStage::STAGE_MULTIPLYADD:                           // Arg3 + Arg1 * Arg2
 977                         {
 978                                 res.x = MulHigh(arg1->x, arg2->x) << 4; res.x = AddSat(res.x, arg3->x);
 979                                 res.y = MulHigh(arg1->y, arg2->y) << 4; res.y = AddSat(res.y, arg3->y);
 980                                 res.z = MulHigh(arg1->z, arg2->z) << 4; res.z = AddSat(res.z, arg3->z);
 981                         }
 982                         break;
 983                 case TextureStage::STAGE_LERP:                                          // Arg3 * (Arg1 - Arg2) + Arg2
 984                         {
 985                                 res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, arg3->x) << 4; res.x = AddSat(res.x, arg2->x);
 986                                 res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, arg3->y) << 4; res.y = AddSat(res.y, arg2->y);
 987                                 res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, arg3->z) << 4; res.z = AddSat(res.z, arg2->z);
 988                         }
 989                         break;
 990                 case TextureStage::STAGE_DOT3:                                          // 2 * (Arg1.x - 0.5) * 2 * (Arg2.x - 0.5) + 2 * (Arg1.y - 0.5) * 2 * (Arg2.y - 0.5) + 2 * (Arg1.z - 0.5) * 2 * (Arg2.z - 0.5)
 991                         {
 992                                 Short4 tmp;
 993
 994                                 res.x = SubSat(arg1->x, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->x, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.x = MulHigh(res.x, tmp);
 995                                 res.y = SubSat(arg1->y, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->y, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.y = MulHigh(res.y, tmp);
 996                                 res.z = SubSat(arg1->z, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->z, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.z = MulHigh(res.z, tmp);
 997
 998                                 res.x = res.x << 6;
 999                                 res.y = res.y << 6;
1000                                 res.z = res.z << 6;
1001
1002                                 res.x = AddSat(res.x, res.y);
1003                                 res.x = AddSat(res.x, res.z);
1004
1005                                 // Clamp to [0, 1]
1006                                 res.x = Max(res.x, Short4(0x0000, 0x0000, 0x0000, 0x0000));
1007                                 res.x = Min(res.x, Short4(0x1000));
1008
1009                                 res.y = res.x;
1010                                 res.z = res.x;
1011                                 res.w = res.x;
1012                         }
1013                         break;
1014                 case TextureStage::STAGE_BLENDCURRENTALPHA:                     // Alpha * (Arg1 - Arg2) + Arg2
1015                         {
1016                                 res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, r.current.w) << 4; res.x = AddSat(res.x, arg2->x);
1017                                 res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, r.current.w) << 4; res.y = AddSat(res.y, arg2->y);
1018                                 res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, r.current.w) << 4; res.z = AddSat(res.z, arg2->z);
1019                         }
1020                         break;
1021                 case TextureStage::STAGE_BLENDDIFFUSEALPHA:                     // Alpha * (Arg1 - Arg2) + Arg2
1022                         {
1023                                 res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, r.diffuse.w) << 4; res.x = AddSat(res.x, arg2->x);
1024                                 res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, r.diffuse.w) << 4; res.y = AddSat(res.y, arg2->y);
1025                                 res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, r.diffuse.w) << 4; res.z = AddSat(res.z, arg2->z);
1026                         }
1027                         break;
1028                 case TextureStage::STAGE_BLENDFACTORALPHA:                      // Alpha * (Arg1 - Arg2) + Arg2
1029                         {
1030                                 res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.x = AddSat(res.x, arg2->x);
1031                                 res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.y = AddSat(res.y, arg2->y);
1032                                 res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.z = AddSat(res.z, arg2->z);
1033                         }
1034                         break;
1035                 case TextureStage::STAGE_BLENDTEXTUREALPHA:                     // Alpha * (Arg1 - Arg2) + Arg2
1036                         {
1037                                 res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, texture.w) << 4; res.x = AddSat(res.x, arg2->x);
1038                                 res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, texture.w) << 4; res.y = AddSat(res.y, arg2->y);
1039                                 res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, texture.w) << 4; res.z = AddSat(res.z, arg2->z);
1040                         }
1041                         break;
1042                 case TextureStage::STAGE_BLENDTEXTUREALPHAPM:           // Arg1 + Arg2 * (1 - Alpha)
1043                         {
1044                                 res.x = SubSat(Short4(0x1000), texture.w); res.x = MulHigh(res.x, arg2->x) << 4; res.x = AddSat(res.x, arg1->x);
1045                                 res.y = SubSat(Short4(0x1000), texture.w); res.y = MulHigh(res.y, arg2->y) << 4; res.y = AddSat(res.y, arg1->y);
1046                                 res.z = SubSat(Short4(0x1000), texture.w); res.z = MulHigh(res.z, arg2->z) << 4; res.z = AddSat(res.z, arg1->z);
1047                         }
1048                         break;
1049                 case TextureStage::STAGE_PREMODULATE:
1050                         {
1051                                 res.x = arg1->x;
1052                                 res.y = arg1->y;
1053                                 res.z = arg1->z;
1054                         }
1055                         break;
1056                 case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:                // Arg1 + Arg1.w * Arg2
1057                         {
1058                                 res.x = MulHigh(arg1->w, arg2->x) << 4; res.x = AddSat(res.x, arg1->x);
1059                                 res.y = MulHigh(arg1->w, arg2->y) << 4; res.y = AddSat(res.y, arg1->y);
1060                                 res.z = MulHigh(arg1->w, arg2->z) << 4; res.z = AddSat(res.z, arg1->z);
1061                         }
1062                         break;
1063                 case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:                // Arg1 * Arg2 + Arg1.w
1064                         {
1065                                 res.x = MulHigh(arg1->x, arg2->x) << 4; res.x = AddSat(res.x, arg1->w);
1066                                 res.y = MulHigh(arg1->y, arg2->y) << 4; res.y = AddSat(res.y, arg1->w);
1067                                 res.z = MulHigh(arg1->z, arg2->z) << 4; res.z = AddSat(res.z, arg1->w);
1068                         }
1069                         break;
1070                 case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:     // (1 - Arg1.w) * Arg2 + Arg1
1071                         {
1072                                 Short4 tmp;
1073
1074                                 res.x = AddSat(arg1->x, arg2->x); tmp = MulHigh(arg1->w, arg2->x) << 4; res.x = SubSat(res.x, tmp);
1075                                 res.y = AddSat(arg1->y, arg2->y); tmp = MulHigh(arg1->w, arg2->y) << 4; res.y = SubSat(res.y, tmp);
1076                                 res.z = AddSat(arg1->z, arg2->z); tmp = MulHigh(arg1->w, arg2->z) << 4; res.z = SubSat(res.z, tmp);
1077                         }
1078                         break;
1079                 case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:     // (1 - Arg1) * Arg2 + Arg1.w
1080                         {
1081                                 Short4 tmp;
1082
1083                                 res.x = AddSat(arg1->w, arg2->x); tmp = MulHigh(arg1->x, arg2->x) << 4; res.x = SubSat(res.x, tmp);
1084                                 res.y = AddSat(arg1->w, arg2->y); tmp = MulHigh(arg1->y, arg2->y) << 4; res.y = SubSat(res.y, tmp);
1085                                 res.z = AddSat(arg1->w, arg2->z); tmp = MulHigh(arg1->z, arg2->z) << 4; res.z = SubSat(res.z, tmp);
1086                         }
1087                         break;
1088                 case TextureStage::STAGE_BUMPENVMAP:
1089                         {
1090                                 r.du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
1091                                 r.dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
1092
1093                                 Float4 du2;
1094                                 Float4 dv2;
1095
1096                                 du2 = r.du;
1097                                 dv2 = r.dv;
1098                                 r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
1099                                 dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
1100                                 r.du += dv2;
1101                                 r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
1102                                 du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
1103                                 r.dv += du2;
1104
1105                                 perturbate = true;
1106
1107                                 res.x = r.current.x;
1108                                 res.y = r.current.y;
1109                                 res.z = r.current.z;
1110                                 res.w = r.current.w;
1111                         }
1112                         break;
1113                 case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
1114                         {
1115                                 r.du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
1116                                 r.dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
1117
1118                                 Float4 du2;
1119                                 Float4 dv2;
1120
1121                                 du2 = r.du;
1122                                 dv2 = r.dv;
1123
1124                                 r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
1125                                 dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
1126                                 r.du += dv2;
1127                                 r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
1128                                 du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
1129                                 r.dv += du2;
1130
1131                                 perturbate = true;
1132
1133                                 r.L = texture.z;
1134                                 r.L = MulHigh(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceScale4)));
1135                                 r.L = r.L << 4;
1136                                 r.L = AddSat(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceOffset4)));
1137                                 r.L = Max(r.L, Short4(0x0000, 0x0000, 0x0000, 0x0000));
1138                                 r.L = Min(r.L, Short4(0x1000));
1139
1140                                 luminance = true;
1141
1142                                 res.x = r.current.x;
1143                                 res.y = r.current.y;
1144                                 res.z = r.current.z;
1145                                 res.w = r.current.w;
1146                         }
1147                         break;
1148                 default:
1149                         ASSERT(false);
1150                 }
1151
1152                 if(textureStage.stageOperation != TextureStage::STAGE_DOT3)
1153                 {
1154                         switch(textureStage.firstArgumentAlpha)
1155                         {
1156                         case TextureStage::SOURCE_TEXTURE:      arg1 = &texture;                break;
1157                         case TextureStage::SOURCE_CONSTANT:     arg1 = &constant;               break;
1158                         case TextureStage::SOURCE_CURRENT:      arg1 = &r.current;              break;
1159                         case TextureStage::SOURCE_DIFFUSE:      arg1 = &r.diffuse;              break;
1160                         case TextureStage::SOURCE_SPECULAR:     arg1 = &r.specular;             break;
1161                         case TextureStage::SOURCE_TEMP:         arg1 = &temp;                   break;
1162                         case TextureStage::SOURCE_TFACTOR:      arg1 = &tfactor;                break;
1163                         default:
1164                                 ASSERT(false);
1165                         }
1166
1167                         switch(textureStage.secondArgumentAlpha)
1168                         {
1169                         case TextureStage::SOURCE_TEXTURE:      arg2 = &texture;                break;
1170                         case TextureStage::SOURCE_CONSTANT:     arg2 = &constant;               break;
1171                         case TextureStage::SOURCE_CURRENT:      arg2 = &r.current;              break;
1172                         case TextureStage::SOURCE_DIFFUSE:      arg2 = &r.diffuse;              break;
1173                         case TextureStage::SOURCE_SPECULAR:     arg2 = &r.specular;             break;
1174                         case TextureStage::SOURCE_TEMP:         arg2 = &temp;                   break;
1175                         case TextureStage::SOURCE_TFACTOR:      arg2 = &tfactor;                break;
1176                         default:
1177                                 ASSERT(false);
1178                         }
1179
1180                         switch(textureStage.thirdArgumentAlpha)
1181                         {
1182                         case TextureStage::SOURCE_TEXTURE:      arg3 = &texture;                break;
1183                         case TextureStage::SOURCE_CONSTANT:     arg3 = &constant;               break;
1184                         case TextureStage::SOURCE_CURRENT:      arg3 = &r.current;              break;
1185                         case TextureStage::SOURCE_DIFFUSE:      arg3 = &r.diffuse;              break;
1186                         case TextureStage::SOURCE_SPECULAR:     arg3 = &r.specular;             break;
1187                         case TextureStage::SOURCE_TEMP:         arg3 = &temp;                   break;
1188                         case TextureStage::SOURCE_TFACTOR:      arg3 = &tfactor;                break;
1189                         default:
1190                                 ASSERT(false);
1191                         }
1192
1193                         switch(textureStage.firstModifierAlpha)   // FIXME: Check if actually used
1194                         {
1195                         case TextureStage::MODIFIER_COLOR:
1196                                 break;
1197                         case TextureStage::MODIFIER_INVCOLOR:
1198                                 {
1199                                         mod1.w = SubSat(Short4(0x1000), arg1->w);
1200
1201                                         arg1 = &mod1;
1202                                 }
1203                                 break;
1204                         case TextureStage::MODIFIER_ALPHA:
1205                                 {
1206                                         // Redudant
1207                                 }
1208                                 break;
1209                         case TextureStage::MODIFIER_INVALPHA:
1210                                 {
1211                                         mod1.w = SubSat(Short4(0x1000), arg1->w);
1212
1213                                         arg1 = &mod1;
1214                                 }
1215                                 break;
1216                         default:
1217                                 ASSERT(false);
1218                         }
1219
1220                         switch(textureStage.secondModifierAlpha)   // FIXME: Check if actually used
1221                         {
1222                         case TextureStage::MODIFIER_COLOR:
1223                                 break;
1224                         case TextureStage::MODIFIER_INVCOLOR:
1225                                 {
1226                                         mod2.w = SubSat(Short4(0x1000), arg2->w);
1227
1228                                         arg2 = &mod2;
1229                                 }
1230                                 break;
1231                         case TextureStage::MODIFIER_ALPHA:
1232                                 {
1233                                         // Redudant
1234                                 }
1235                                 break;
1236                         case TextureStage::MODIFIER_INVALPHA:
1237                                 {
1238                                         mod2.w = SubSat(Short4(0x1000), arg2->w);
1239
1240                                         arg2 = &mod2;
1241                                 }
1242                                 break;
1243                         default:
1244                                 ASSERT(false);
1245                         }
1246
1247                         switch(textureStage.thirdModifierAlpha)   // FIXME: Check if actually used
1248                         {
1249                         case TextureStage::MODIFIER_COLOR:
1250                                 break;
1251                         case TextureStage::MODIFIER_INVCOLOR:
1252                                 {
1253                                         mod3.w = SubSat(Short4(0x1000), arg3->w);
1254
1255                                         arg3 = &mod3;
1256                                 }
1257                                 break;
1258                         case TextureStage::MODIFIER_ALPHA:
1259                                 {
1260                                         // Redudant
1261                                 }
1262                                 break;
1263                         case TextureStage::MODIFIER_INVALPHA:
1264                                 {
1265                                         mod3.w = SubSat(Short4(0x1000), arg3->w);
1266
1267                                         arg3 = &mod3;
1268                                 }
1269                                 break;
1270                         default:
1271                                 ASSERT(false);
1272                         }
1273
1274                         switch(textureStage.stageOperationAlpha)
1275                         {
1276                         case TextureStage::STAGE_DISABLE:
1277                                 break;
1278                         case TextureStage::STAGE_SELECTARG1:                                    // Arg1
1279                                 {
1280                                         res.w = arg1->w;
1281                                 }
1282                                 break;
1283                         case TextureStage::STAGE_SELECTARG2:                                    // Arg2
1284                                 {
1285                                         res.w = arg2->w;
1286                                 }
1287                                 break;
1288                         case TextureStage::STAGE_SELECTARG3:                                    // Arg3
1289                                 {
1290                                         res.w = arg3->w;
1291                                 }
1292                                 break;
1293                         case TextureStage::STAGE_MODULATE:                                      // Arg1 * Arg2
1294                                 {
1295                                         res.w = MulHigh(arg1->w, arg2->w) << 4;
1296                                 }
1297                                 break;
1298                         case TextureStage::STAGE_MODULATE2X:                                    // Arg1 * Arg2 * 2
1299                                 {
1300                                         res.w = MulHigh(arg1->w, arg2->w) << 5;
1301                                 }
1302                                 break;
1303                         case TextureStage::STAGE_MODULATE4X:                                    // Arg1 * Arg2 * 4
1304                                 {
1305                                         res.w = MulHigh(arg1->w, arg2->w) << 6;
1306                                 }
1307                                 break;
1308                         case TextureStage::STAGE_ADD:                                           // Arg1 + Arg2
1309                                 {
1310                                         res.w = AddSat(arg1->w, arg2->w);
1311                                 }
1312                                 break;
1313                         case TextureStage::STAGE_ADDSIGNED:                                     // Arg1 + Arg2 - 0.5
1314                                 {
1315                                         res.w = AddSat(arg1->w, arg2->w);
1316                                         res.w = SubSat(res.w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
1317                                 }
1318                                 break;
1319                         case TextureStage::STAGE_ADDSIGNED2X:                                   // (Arg1 + Arg2 - 0.5) << 1
1320                                 {
1321                                         res.w = AddSat(arg1->w, arg2->w);
1322                                         res.w = SubSat(res.w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
1323                                         res.w = AddSat(res.w, res.w);
1324                                 }
1325                                 break;
1326                         case TextureStage::STAGE_SUBTRACT:                                      // Arg1 - Arg2
1327                                 {
1328                                         res.w = SubSat(arg1->w, arg2->w);
1329                                 }
1330                                 break;
1331                         case TextureStage::STAGE_ADDSMOOTH:                                     // Arg1 + Arg2 - Arg1 * Arg2
1332                                 {
1333                                         Short4 tmp;
1334
1335                                         tmp = MulHigh(arg1->w, arg2->w) << 4; res.w = AddSat(arg1->w, arg2->w); res.w = SubSat(res.w, tmp);
1336                                 }
1337                                 break;
1338                         case TextureStage::STAGE_MULTIPLYADD:                           // Arg3 + Arg1 * Arg2
1339                                 {
1340                                         res.w = MulHigh(arg1->w, arg2->w) << 4; res.w = AddSat(res.w, arg3->w);
1341                                 }
1342                                 break;
1343                         case TextureStage::STAGE_LERP:                                          // Arg3 * (Arg1 - Arg2) + Arg2
1344                                 {
1345                                         res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, arg3->w) << 4; res.w = AddSat(res.w, arg2->w);
1346                                 }
1347                                 break;
1348                         case TextureStage::STAGE_DOT3:
1349                                 break;   // Already computed in color channel
1350                         case TextureStage::STAGE_BLENDCURRENTALPHA:                     // Alpha * (Arg1 - Arg2) + Arg2
1351                                 {
1352                                         res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, r.current.w) << 4; res.w = AddSat(res.w, arg2->w);
1353                                 }
1354                                 break;
1355                         case TextureStage::STAGE_BLENDDIFFUSEALPHA:                     // Arg1 * (Alpha) + Arg2 * (1 - Alpha)
1356                                 {
1357                                         res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, r.diffuse.w) << 4; res.w = AddSat(res.w, arg2->w);
1358                                 }
1359                                 break;
1360                         case TextureStage::STAGE_BLENDFACTORALPHA:
1361                                 {
1362                                         res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.w = AddSat(res.w, arg2->w);
1363                                 }
1364                                 break;
1365                         case TextureStage::STAGE_BLENDTEXTUREALPHA:                     // Arg1 * (Alpha) + Arg2 * (1 - Alpha)
1366                                 {
1367                                         res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, texture.w) << 4; res.w = AddSat(res.w, arg2->w);
1368                                 }
1369                                 break;
1370                         case TextureStage::STAGE_BLENDTEXTUREALPHAPM:           // Arg1 + Arg2 * (1 - Alpha)
1371                                 {
1372                                         res.w = SubSat(Short4(0x1000), texture.w); res.w = MulHigh(res.w, arg2->w) << 4; res.w = AddSat(res.w, arg1->w);
1373                                 }
1374                                 break;
1375                         case TextureStage::STAGE_PREMODULATE:
1376                                 {
1377                                         res.w = arg1->w;
1378                                 }
1379                                 break;
1380                         case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
1381                         case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
1382                         case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
1383                         case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
1384                         case TextureStage::STAGE_BUMPENVMAP:
1385                         case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
1386                                 break;   // Invalid alpha operations
1387                         default:
1388                                 ASSERT(false);
1389                         }
1390                 }
1391
1392                 // Clamp result to [0, 1]
1393
1394                 switch(textureStage.stageOperation)
1395                 {
1396                 case TextureStage::STAGE_DISABLE:
1397                 case TextureStage::STAGE_SELECTARG1:
1398                 case TextureStage::STAGE_SELECTARG2:
1399                 case TextureStage::STAGE_SELECTARG3:
1400                 case TextureStage::STAGE_MODULATE:
1401                 case TextureStage::STAGE_MODULATE2X:
1402                 case TextureStage::STAGE_MODULATE4X:
1403                 case TextureStage::STAGE_ADD:
1404                 case TextureStage::STAGE_MULTIPLYADD:
1405                 case TextureStage::STAGE_LERP:
1406                 case TextureStage::STAGE_BLENDCURRENTALPHA:
1407                 case TextureStage::STAGE_BLENDDIFFUSEALPHA:
1408                 case TextureStage::STAGE_BLENDFACTORALPHA:
1409                 case TextureStage::STAGE_BLENDTEXTUREALPHA:
1410                 case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
1411                 case TextureStage::STAGE_DOT3:   // Already clamped
1412                 case TextureStage::STAGE_PREMODULATE:
1413                 case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
1414                 case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
1415                 case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
1416                 case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
1417                 case TextureStage::STAGE_BUMPENVMAP:
1418                 case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
1419                         if(state.textureStage[stage].cantUnderflow)
1420                         {
1421                                 break;   // Can't go below zero
1422                         }
1423                 case TextureStage::STAGE_ADDSIGNED:
1424                 case TextureStage::STAGE_ADDSIGNED2X:
1425                 case TextureStage::STAGE_SUBTRACT:
1426                 case TextureStage::STAGE_ADDSMOOTH:
1427                         res.x = Max(res.x, Short4(0x0000, 0x0000, 0x0000, 0x0000));
1428                         res.y = Max(res.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));
1429                         res.z = Max(res.z, Short4(0x0000, 0x0000, 0x0000, 0x0000));
1430                         break;
1431                 default:
1432                         ASSERT(false);
1433                 }
1434
1435                 switch(textureStage.stageOperationAlpha)
1436                 {
1437                 case TextureStage::STAGE_DISABLE:
1438                 case TextureStage::STAGE_SELECTARG1:
1439                 case TextureStage::STAGE_SELECTARG2:
1440                 case TextureStage::STAGE_SELECTARG3:
1441                 case TextureStage::STAGE_MODULATE:
1442                 case TextureStage::STAGE_MODULATE2X:
1443                 case TextureStage::STAGE_MODULATE4X:
1444                 case TextureStage::STAGE_ADD:
1445                 case TextureStage::STAGE_MULTIPLYADD:
1446                 case TextureStage::STAGE_LERP:
1447                 case TextureStage::STAGE_BLENDCURRENTALPHA:
1448                 case TextureStage::STAGE_BLENDDIFFUSEALPHA:
1449                 case TextureStage::STAGE_BLENDFACTORALPHA:
1450                 case TextureStage::STAGE_BLENDTEXTUREALPHA:
1451                 case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
1452                 case TextureStage::STAGE_DOT3:   // Already clamped
1453                 case TextureStage::STAGE_PREMODULATE:
1454                 case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
1455                 case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
1456                 case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
1457                 case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
1458                 case TextureStage::STAGE_BUMPENVMAP:
1459                 case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
1460                         if(state.textureStage[stage].cantUnderflow)
1461                         {
1462                                 break;   // Can't go below zero
1463                         }
1464                 case TextureStage::STAGE_ADDSIGNED:
1465                 case TextureStage::STAGE_ADDSIGNED2X:
1466                 case TextureStage::STAGE_SUBTRACT:
1467                 case TextureStage::STAGE_ADDSMOOTH:
1468                         res.w = Max(res.w, Short4(0x0000, 0x0000, 0x0000, 0x0000));
1469                         break;
1470                 default:
1471                         ASSERT(false);
1472                 }
1473
1474                 switch(textureStage.stageOperation)
1475                 {
1476                 case TextureStage::STAGE_DISABLE:
1477                 case TextureStage::STAGE_SELECTARG1:
1478                 case TextureStage::STAGE_SELECTARG2:
1479                 case TextureStage::STAGE_SELECTARG3:
1480                 case TextureStage::STAGE_MODULATE:
1481                 case TextureStage::STAGE_SUBTRACT:
1482                 case TextureStage::STAGE_ADDSMOOTH:
1483                 case TextureStage::STAGE_LERP:
1484                 case TextureStage::STAGE_BLENDCURRENTALPHA:
1485                 case TextureStage::STAGE_BLENDDIFFUSEALPHA:
1486                 case TextureStage::STAGE_BLENDFACTORALPHA:
1487                 case TextureStage::STAGE_BLENDTEXTUREALPHA:
1488                 case TextureStage::STAGE_DOT3:   // Already clamped
1489                 case TextureStage::STAGE_PREMODULATE:
1490                 case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
1491                 case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
1492                 case TextureStage::STAGE_BUMPENVMAP:
1493                 case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
1494                         break;   // Can't go above one
1495                 case TextureStage::STAGE_MODULATE2X:
1496                 case TextureStage::STAGE_MODULATE4X:
1497                 case TextureStage::STAGE_ADD:
1498                 case TextureStage::STAGE_ADDSIGNED:
1499                 case TextureStage::STAGE_ADDSIGNED2X:
1500                 case TextureStage::STAGE_MULTIPLYADD:
1501                 case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
1502                 case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
1503                 case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
1504                         res.x = Min(res.x, Short4(0x1000));
1505                         res.y = Min(res.y, Short4(0x1000));
1506                         res.z = Min(res.z, Short4(0x1000));
1507                         break;
1508                 default:
1509                         ASSERT(false);
1510                 }
1511
1512                 switch(textureStage.stageOperationAlpha)
1513                 {
1514                 case TextureStage::STAGE_DISABLE:
1515                 case TextureStage::STAGE_SELECTARG1:
1516                 case TextureStage::STAGE_SELECTARG2:
1517                 case TextureStage::STAGE_SELECTARG3:
1518                 case TextureStage::STAGE_MODULATE:
1519                 case TextureStage::STAGE_SUBTRACT:
1520                 case TextureStage::STAGE_ADDSMOOTH:
1521                 case TextureStage::STAGE_LERP:
1522                 case TextureStage::STAGE_BLENDCURRENTALPHA:
1523                 case TextureStage::STAGE_BLENDDIFFUSEALPHA:
1524                 case TextureStage::STAGE_BLENDFACTORALPHA:
1525                 case TextureStage::STAGE_BLENDTEXTUREALPHA:
1526                 case TextureStage::STAGE_DOT3:   // Already clamped
1527                 case TextureStage::STAGE_PREMODULATE:
1528                 case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
1529                 case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
1530                 case TextureStage::STAGE_BUMPENVMAP:
1531                 case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
1532                         break;   // Can't go above one
1533                 case TextureStage::STAGE_MODULATE2X:
1534                 case TextureStage::STAGE_MODULATE4X:
1535                 case TextureStage::STAGE_ADD:
1536                 case TextureStage::STAGE_ADDSIGNED:
1537                 case TextureStage::STAGE_ADDSIGNED2X:
1538                 case TextureStage::STAGE_MULTIPLYADD:
1539                 case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
1540                 case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
1541                 case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
1542                         res.w = Min(res.w, Short4(0x1000));
1543                         break;
1544                 default:
1545                         ASSERT(false);
1546                 }
1547
1548                 switch(textureStage.destinationArgument)
1549                 {
1550                 case TextureStage::DESTINATION_CURRENT:
1551                         r.current.x = res.x;
1552                         r.current.y = res.y;
1553                         r.current.z = res.z;
1554                         r.current.w = res.w;
1555                         break;
1556                 case TextureStage::DESTINATION_TEMP:
1557                         temp.x = res.x;
1558                         temp.y = res.y;
1559                         temp.z = res.z;
1560                         temp.w = res.w;
1561                         break;
1562                 default:
1563                         ASSERT(false);
1564                 }
1565         }
1566
1567         void PixelRoutine::alphaTest(Registers &r, Int &aMask, Short4 &alpha)
1568         {
1569                 Short4 cmp;
1570                 Short4 equal;
1571
1572                 switch(state.alphaCompareMode)
1573                 {
1574                 case ALPHA_ALWAYS:
1575                         aMask = 0xF;
1576                         break;
1577                 case ALPHA_NEVER:
1578                         aMask = 0x0;
1579                         break;
1580                 case ALPHA_EQUAL:
1581                         cmp = CmpEQ(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
1582                         aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
1583                         break;
1584                 case ALPHA_NOTEQUAL:            // a != b ~ !(a == b)
1585                         cmp = CmpEQ(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4((short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF);   // FIXME
1586                         aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
1587                         break;
1588                 case ALPHA_LESS:                        // a < b ~ b > a
1589                         cmp = CmpGT(*Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)), alpha);
1590                         aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
1591                         break;
1592                 case ALPHA_GREATEREQUAL:        // a >= b ~ (a > b) || (a == b) ~ !(b > a)   // TODO: Approximate
1593                         equal = CmpEQ(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
1594                         cmp = CmpGT(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
1595                         cmp |= equal;
1596                         aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
1597                         break;
1598                 case ALPHA_LESSEQUAL:           // a <= b ~ !(a > b)
1599                         cmp = CmpGT(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4((short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF);   // FIXME
1600                         aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
1601                         break;
1602                 case ALPHA_GREATER:                     // a > b
1603                         cmp = CmpGT(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
1604                         aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
1605                         break;
1606                 default:
1607                         ASSERT(false);
1608                 }
1609         }
1610
1611         void PixelRoutine::alphaToCoverage(Registers &r, Int cMask[4], Float4 &alpha)
1612         {
1613                 Int4 coverage0 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c0)));
1614                 Int4 coverage1 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c1)));
1615                 Int4 coverage2 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c2)));
1616                 Int4 coverage3 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c3)));
1617
1618                 Int aMask0 = SignMask(coverage0);
1619                 Int aMask1 = SignMask(coverage1);
1620                 Int aMask2 = SignMask(coverage2);
1621                 Int aMask3 = SignMask(coverage3);
1622
1623                 cMask[0] &= aMask0;
1624                 cMask[1] &= aMask1;
1625                 cMask[2] &= aMask2;
1626                 cMask[3] &= aMask3;
1627         }
1628
1629         Bool PixelRoutine::alphaTest(Registers &r, Int cMask[4], Vector4s &current)
1630         {
1631                 if(!state.alphaTestActive())
1632                 {
1633                         return true;
1634                 }
1635
1636                 Int aMask;
1637
1638                 if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
1639                 {
1640                         alphaTest(r, aMask, current.w);
1641
1642                         for(unsigned int q = 0; q < state.multiSample; q++)
1643                         {
1644                                 cMask[q] &= aMask;
1645                         }
1646                 }
1647                 else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
1648                 {
1649                         Float4 alpha = Float4(current.w) * Float4(1.0f / 0x1000);
1650
1651                         alphaToCoverage(r, cMask, alpha);
1652                 }
1653                 else ASSERT(false);
1654
1655                 Int pass = cMask[0];
1656
1657                 for(unsigned int q = 1; q < state.multiSample; q++)
1658                 {
1659                         pass = pass | cMask[q];
1660                 }
1661
1662                 return pass != 0x0;
1663         }
1664
1665         Bool PixelRoutine::alphaTest(Registers &r, Int cMask[4], Vector4f &c0)
1666         {
1667                 if(!state.alphaTestActive())
1668                 {
1669                         return true;
1670                 }
1671
1672                 Int aMask;
1673
1674                 if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
1675                 {
1676                         Short4 alpha = RoundShort4(c0.w * Float4(0x1000));
1677
1678                         alphaTest(r, aMask, alpha);
1679
1680                         for(unsigned int q = 0; q < state.multiSample; q++)
1681                         {
1682                                 cMask[q] &= aMask;
1683                         }
1684                 }
1685                 else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
1686                 {
1687                         alphaToCoverage(r, cMask, c0.w);
1688                 }
1689                 else ASSERT(false);
1690
1691                 Int pass = cMask[0];
1692
1693                 for(unsigned int q = 1; q < state.multiSample; q++)
1694                 {
1695                         pass = pass | cMask[q];
1696                 }
1697
1698                 return pass != 0x0;
1699         }
1700
1701         void PixelRoutine::fogBlend(Registers &r, Vector4s &current, Float4 &f, Float4 &z, Float4 &rhw)
1702         {
1703                 if(!state.fogActive)
1704                 {
1705                         return;
1706                 }
1707
1708                 if(state.pixelFogMode != FOG_NONE)
1709                 {
1710                         pixelFog(r, f, z, rhw);
1711                 }
1712
1713                 UShort4 fog = convertFixed16(f, true);
1714
1715                 current.x = As<Short4>(MulHigh(As<UShort4>(current.x), fog));
1716                 current.y = As<Short4>(MulHigh(As<UShort4>(current.y), fog));
1717                 current.z = As<Short4>(MulHigh(As<UShort4>(current.z), fog));
1718
1719                 UShort4 invFog = UShort4(0xFFFFu) - fog;
1720
1721                 current.x += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[0]))));
1722                 current.y += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[1]))));
1723                 current.z += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[2]))));
1724         }
1725
1726         void PixelRoutine::fogBlend(Registers &r, Vector4f &c0, Float4 &fog, Float4 &z, Float4 &rhw)
1727         {
1728                 if(!state.fogActive)
1729                 {
1730                         return;
1731                 }
1732
1733                 if(state.pixelFogMode != FOG_NONE)
1734                 {
1735                         pixelFog(r, fog, z, rhw);
1736
1737                         fog = Min(fog, Float4(1.0f));
1738                         fog = Max(fog, Float4(0.0f));
1739                 }
1740
1741                 c0.x -= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[0]));
1742                 c0.y -= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[1]));
1743                 c0.z -= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[2]));
1744
1745                 c0.x *= fog;
1746                 c0.y *= fog;
1747                 c0.z *= fog;
1748
1749                 c0.x += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[0]));
1750                 c0.y += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[1]));
1751                 c0.z += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[2]));
1752         }
1753
1754         void PixelRoutine::pixelFog(Registers &r, Float4 &visibility, Float4 &z, Float4 &rhw)
1755         {
1756                 Float4 &zw = visibility;
1757
1758                 if(state.pixelFogMode != FOG_NONE)
1759                 {
1760                         if(state.wBasedFog)
1761                         {
1762                                 zw = rhw;
1763                         }
1764                         else
1765                         {
1766                                 if(complementaryDepthBuffer)
1767                                 {
1768                                         zw = Float4(1.0f) - z;
1769                                 }
1770                                 else
1771                                 {
1772                                         zw = z;
1773                                 }
1774                         }
1775                 }
1776
1777                 switch(state.pixelFogMode)
1778                 {
1779                 case FOG_NONE:
1780                         break;
1781                 case FOG_LINEAR:
1782                         zw *= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.scale));
1783                         zw += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.offset));
1784                         break;
1785                 case FOG_EXP:
1786                         zw *= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.densityE));
1787                         zw = exponential2(zw, true);
1788                         break;
1789                 case FOG_EXP2:
1790                         zw *= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.densityE2));
1791                         zw *= zw;
1792                         zw = exponential2(zw, true);
1793                         zw = Rcp_pp(zw);
1794                         break;
1795                 default:
1796                         ASSERT(false);
1797                 }
1798         }
1799
1800         void PixelRoutine::specularPixel(Vector4s &current, Vector4s &specular)
1801         {
1802                 if(!state.specularAdd)
1803                 {
1804                         return;
1805                 }
1806
1807                 current.x = AddSat(current.x, specular.x);
1808                 current.y = AddSat(current.y, specular.y);
1809                 current.z = AddSat(current.z, specular.z);
1810         }
1811
1812         void PixelRoutine::writeDepth(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask)
1813         {
1814                 if(!state.depthWriteEnable)
1815                 {
1816                         return;
1817                 }
1818
1819                 Float4 Z = z;
1820
1821                 if(shader && shader->depthOverride())
1822                 {
1823                         if(complementaryDepthBuffer)
1824                         {
1825                                 Z = Float4(1.0f) - r.oDepth;
1826                         }
1827                         else
1828                         {
1829                                 Z = r.oDepth;
1830                         }
1831                 }
1832
1833                 Pointer<Byte> buffer;
1834                 Int pitch;
1835
1836                 if(!state.quadLayoutDepthBuffer)
1837                 {
1838                         buffer = zBuffer + 4 * x;
1839                         pitch = *Pointer<Int>(r.data + OFFSET(DrawData,depthPitchB));
1840                 }
1841                 else
1842                 {
1843                         buffer = zBuffer + 8 * x;
1844                 }
1845
1846                 if(q > 0)
1847                 {
1848                         buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,depthSliceB));
1849                 }
1850
1851                 Float4 zValue;
1852
1853                 if(state.depthCompareMode != DEPTH_NEVER || (state.depthCompareMode != DEPTH_ALWAYS && !state.depthWriteEnable))
1854                 {
1855                         if(!state.quadLayoutDepthBuffer)
1856                         {
1857                                 // FIXME: Properly optimizes?
1858                                 zValue.xy = *Pointer<Float4>(buffer);
1859                                 zValue.zw = *Pointer<Float4>(buffer + pitch - 8);
1860                         }
1861                         else
1862                         {
1863                                 zValue = *Pointer<Float4>(buffer, 16);
1864                         }
1865                 }
1866
1867                 Z = As<Float4>(As<Int4>(Z) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X) + zMask * 16, 16));
1868                 zValue = As<Float4>(As<Int4>(zValue) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X) + zMask * 16, 16));
1869                 Z = As<Float4>(As<Int4>(Z) | As<Int4>(zValue));
1870
1871                 if(!state.quadLayoutDepthBuffer)
1872                 {
1873                         // FIXME: Properly optimizes?
1874                         *Pointer<Float2>(buffer) = Float2(Z.xy);
1875                         *Pointer<Float2>(buffer + pitch) = Float2(Z.zw);
1876                 }
1877                 else
1878                 {
1879                         *Pointer<Float4>(buffer, 16) = Z;
1880                 }
1881         }
1882
1883         void PixelRoutine::writeStencil(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask)
1884         {
1885                 if(!state.stencilActive)
1886                 {
1887                         return;
1888                 }
1889
1890                 if(state.stencilPassOperation == OPERATION_KEEP && state.stencilZFailOperation == OPERATION_KEEP && state.stencilFailOperation == OPERATION_KEEP)
1891                 {
1892                         if(!state.twoSidedStencil || (state.stencilPassOperationCCW == OPERATION_KEEP && state.stencilZFailOperationCCW == OPERATION_KEEP && state.stencilFailOperationCCW == OPERATION_KEEP))
1893                         {
1894                                 return;
1895                         }
1896                 }
1897
1898                 if(state.stencilWriteMasked && (!state.twoSidedStencil || state.stencilWriteMaskedCCW))
1899                 {
1900                         return;
1901                 }
1902
1903                 Pointer<Byte> buffer = sBuffer + 2 * x;
1904
1905                 if(q > 0)
1906                 {
1907                         buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,stencilSliceB));
1908                 }
1909
1910                 Byte8 bufferValue = As<Byte8>(Long1(*Pointer<UInt>(buffer)));
1911
1912                 Byte8 newValue;
1913                 stencilOperation(r, newValue, bufferValue, state.stencilPassOperation, state.stencilZFailOperation, state.stencilFailOperation, false, zMask, sMask);
1914
1915                 if(!state.noStencilWriteMask)
1916                 {
1917                         Byte8 maskedValue = bufferValue;
1918                         newValue &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[0].writeMaskQ));
1919                         maskedValue &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[0].invWriteMaskQ));
1920                         newValue |= maskedValue;
1921                 }
1922
1923                 if(state.twoSidedStencil)
1924                 {
1925                         Byte8 newValueCCW;
1926
1927                         stencilOperation(r, newValueCCW, bufferValue, state.stencilPassOperationCCW, state.stencilZFailOperationCCW, state.stencilFailOperationCCW, true, zMask, sMask);
1928
1929                         if(!state.noStencilWriteMaskCCW)
1930                         {
1931                                 Byte8 maskedValue = bufferValue;
1932                                 newValueCCW &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[1].writeMaskQ));
1933                                 maskedValue &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[1].invWriteMaskQ));
1934                                 newValueCCW |= maskedValue;
1935                         }
1936
1937                         newValue &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,clockwiseMask));
1938                         newValueCCW &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,invClockwiseMask));
1939                         newValue |= newValueCCW;
1940                 }
1941
1942                 newValue &= *Pointer<Byte8>(r.constants + OFFSET(Constants,maskB4Q) + 8 * cMask);
1943                 bufferValue &= *Pointer<Byte8>(r.constants + OFFSET(Constants,invMaskB4Q) + 8 * cMask);
1944                 newValue |= bufferValue;
1945
1946                 *Pointer<UInt>(buffer) = UInt(As<Long>(newValue));
1947         }
1948
1949         void PixelRoutine::stencilOperation(Registers &r, Byte8 &newValue, Byte8 &bufferValue, StencilOperation stencilPassOperation, StencilOperation stencilZFailOperation, StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask)
1950         {
1951                 Byte8 &pass = newValue;
1952                 Byte8 fail;
1953                 Byte8 zFail;
1954
1955                 stencilOperation(r, pass, bufferValue, stencilPassOperation, CCW);
1956
1957                 if(stencilZFailOperation != stencilPassOperation)
1958                 {
1959                         stencilOperation(r, zFail, bufferValue, stencilZFailOperation, CCW);
1960                 }
1961
1962                 if(stencilFailOperation != stencilPassOperation || stencilFailOperation != stencilZFailOperation)
1963                 {
1964                         stencilOperation(r, fail, bufferValue, stencilFailOperation, CCW);
1965                 }
1966
1967                 if(stencilFailOperation != stencilPassOperation || stencilFailOperation != stencilZFailOperation)
1968                 {
1969                         if(state.depthTestActive && stencilZFailOperation != stencilPassOperation)   // zMask valid and values not the same
1970                         {
1971                                 pass &= *Pointer<Byte8>(r.constants + OFFSET(Constants,maskB4Q) + 8 * zMask);
1972                                 zFail &= *Pointer<Byte8>(r.constants + OFFSET(Constants,invMaskB4Q) + 8 * zMask);
1973                                 pass |= zFail;
1974                         }
1975
1976                         pass &= *Pointer<Byte8>(r.constants + OFFSET(Constants,maskB4Q) + 8 * sMask);
1977                         fail &= *Pointer<Byte8>(r.constants + OFFSET(Constants,invMaskB4Q) + 8 * sMask);
1978                         pass |= fail;
1979                 }
1980         }
1981
1982         void PixelRoutine::stencilOperation(Registers &r, Byte8 &output, Byte8 &bufferValue, StencilOperation operation, bool CCW)
1983         {
1984                 switch(operation)
1985                 {
1986                 case OPERATION_KEEP:
1987                         output = bufferValue;
1988                         break;
1989                 case OPERATION_ZERO:
1990                         output = Byte8(0x0000000000000000);
1991                         break;
1992                 case OPERATION_REPLACE:
1993                         output = *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceQ));
1994                         break;
1995                 case OPERATION_INCRSAT:
1996                         output = AddSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
1997                         break;
1998                 case OPERATION_DECRSAT:
1999                         output = SubSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
2000                         break;
2001                 case OPERATION_INVERT:
2002                         output = bufferValue ^ Byte8(0xFFFFFFFFFFFFFFFF);
2003                         break;
2004                 case OPERATION_INCR:
2005                         output = bufferValue + Byte8(1, 1, 1, 1, 1, 1, 1, 1);
2006                         break;
2007                 case OPERATION_DECR:
2008                         output = bufferValue - Byte8(1, 1, 1, 1, 1, 1, 1, 1);
2009                         break;
2010                 default:
2011                         ASSERT(false);
2012                 }
2013         }
2014
2015         void PixelRoutine::sampleTexture(Registers &r, Vector4s &c, int coordinates, int stage, bool project)
2016         {
2017                 Float4 u = r.vf[2 + coordinates].x;
2018                 Float4 v = r.vf[2 + coordinates].y;
2019                 Float4 w = r.vf[2 + coordinates].z;
2020                 Float4 q = r.vf[2 + coordinates].w;
2021
2022                 if(perturbate)
2023                 {
2024                         u += r.du;
2025                         v += r.dv;
2026
2027                         perturbate = false;
2028                 }
2029
2030                 sampleTexture(r, c, stage, u, v, w, q, project);
2031         }
2032
2033         void PixelRoutine::sampleTexture(Registers &r, Vector4s &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project, bool bias, bool fixed12)
2034         {
2035                 Vector4f dsx;
2036                 Vector4f dsy;
2037
2038                 sampleTexture(r, c, stage, u, v, w, q, dsx, dsy, project, bias, fixed12, false);
2039         }
2040
2041         void PixelRoutine::sampleTexture(Registers &r, Vector4s &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool fixed12, bool gradients, bool lodProvided)
2042         {
2043                 #if PERF_PROFILE
2044                         Long texTime = Ticks();
2045                 #endif
2046
2047                 Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap) + stage * sizeof(Texture);
2048
2049                 if(!project)
2050                 {
2051                         sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, fixed12, gradients, lodProvided);
2052                 }
2053                 else
2054                 {
2055                         Float4 rq = reciprocal(q);
2056
2057                         Float4 u_q = u * rq;
2058                         Float4 v_q = v * rq;
2059                         Float4 w_q = w * rq;
2060
2061                         sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, fixed12, gradients, lodProvided);
2062                 }
2063
2064                 #if PERF_PROFILE
2065                         r.cycles[PERF_TEX] += Ticks() - texTime;
2066                 #endif
2067         }
2068
2069         void PixelRoutine::sampleTexture(Registers &r, Vector4f &c, const Src &sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
2070         {
2071                 if(sampler.type == Shader::PARAMETER_SAMPLER && sampler.rel.type == Shader::PARAMETER_VOID)
2072                 {
2073                         sampleTexture(r, c, sampler.index, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);
2074                 }
2075                 else
2076                 {
2077                         Int index = As<Int>(Float(fetchRegisterF(r, sampler).x.x));
2078
2079                         for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
2080                         {
2081                                 if(shader->usesSampler(i))
2082                                 {
2083                                         If(index == i)
2084                                         {
2085                                                 sampleTexture(r, c, i, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);
2086                                                 // FIXME: When the sampler states are the same, we could use one sampler and just index the texture
2087                                         }
2088                                 }
2089                         }
2090                 }
2091         }
2092
2093         void PixelRoutine::sampleTexture(Registers &r, Vector4f &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
2094         {
2095                 #if PERF_PROFILE
2096                         Long texTime = Ticks();
2097                 #endif
2098
2099                 Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap) + stage * sizeof(Texture);
2100
2101                 if(!project)
2102                 {
2103                         sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
2104                 }
2105                 else
2106                 {
2107                         Float4 rq = reciprocal(q);
2108
2109                         Float4 u_q = u * rq;
2110                         Float4 v_q = v * rq;
2111                         Float4 w_q = w * rq;
2112
2113                         sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, gradients, lodProvided);
2114                 }
2115
2116                 #if PERF_PROFILE
2117                         r.cycles[PERF_TEX] += Ticks() - texTime;
2118                 #endif
2119         }
2120
2121         void PixelRoutine::clampColor(Vector4f oC[4])
2122         {
2123                 for(int index = 0; index < 4; index++)
2124                 {
2125                         if(!state.colorWriteActive(index) && !(index == 0 && state.alphaTestActive()))
2126                         {
2127                                 continue;
2128                         }
2129
2130                         switch(state.targetFormat[index])
2131                         {
2132                         case FORMAT_NULL:
2133                                 break;
2134                         case FORMAT_A16B16G16R16:
2135                         case FORMAT_A8R8G8B8:
2136                         case FORMAT_A8B8G8R8:
2137                         case FORMAT_X8R8G8B8:
2138                         case FORMAT_X8B8G8R8:
2139                         case FORMAT_A8:
2140                         case FORMAT_G16R16:
2141                                 oC[index].x = Max(oC[index].x, Float4(0.0f)); oC[index].x = Min(oC[index].x, Float4(1.0f));
2142                                 oC[index].y = Max(oC[index].y, Float4(0.0f)); oC[index].y = Min(oC[index].y, Float4(1.0f));
2143                                 oC[index].z = Max(oC[index].z, Float4(0.0f)); oC[index].z = Min(oC[index].z, Float4(1.0f));
2144                                 oC[index].w = Max(oC[index].w, Float4(0.0f)); oC[index].w = Min(oC[index].w, Float4(1.0f));
2145                                 break;
2146                         case FORMAT_R32F:
2147                         case FORMAT_G32R32F:
2148                         case FORMAT_A32B32G32R32F:
2149                                 break;
2150                         default:
2151                                 ASSERT(false);
2152                         }
2153                 }
2154         }
2155
2156         void PixelRoutine::rasterOperation(Vector4s &current, Registers &r, Float4 &fog, Pointer<Byte> &cBuffer, Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
2157         {
2158                 if(!state.colorWriteActive(0))
2159                 {
2160                         return;
2161                 }
2162
2163                 Vector4f oC;
2164
2165                 switch(state.targetFormat[0])
2166                 {
2167                 case FORMAT_X8R8G8B8:
2168                 case FORMAT_X8B8G8R8:
2169                 case FORMAT_A8R8G8B8:
2170                 case FORMAT_A8B8G8R8:
2171                 case FORMAT_A8:
2172                 case FORMAT_G16R16:
2173                 case FORMAT_A16B16G16R16:
2174                         if(!postBlendSRGB && state.writeSRGB)
2175                         {
2176                                 linearToSRGB12_16(r, current);
2177                         }
2178                         else
2179                         {
2180                                 current.x <<= 4;
2181                                 current.y <<= 4;
2182                                 current.z <<= 4;
2183                                 current.w <<= 4;
2184                         }
2185
2186                         fogBlend(r, current, fog, r.z[0], r.rhw);
2187
2188                         for(unsigned int q = 0; q < state.multiSample; q++)
2189                         {
2190                                 Pointer<Byte> buffer = cBuffer + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[0]));
2191                                 Vector4s color = current;
2192
2193                                 if(state.multiSampleMask & (1 << q))
2194                                 {
2195                                         alphaBlend(r, 0, buffer, color, x);
2196                                         writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
2197                                 }
2198                         }
2199                         break;
2200                 case FORMAT_R32F:
2201                 case FORMAT_G32R32F:
2202                 case FORMAT_A32B32G32R32F:
2203                         convertSigned12(oC, current);
2204                         fogBlend(r, oC, fog, r.z[0], r.rhw);
2205
2206                         for(unsigned int q = 0; q < state.multiSample; q++)
2207                         {
2208                                 Pointer<Byte> buffer = cBuffer + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[0]));
2209                                 Vector4f color = oC;
2210
2211                                 if(state.multiSampleMask & (1 << q))
2212                                 {
2213                                         alphaBlend(r, 0, buffer, color, x);
2214                                         writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
2215                                 }
2216                         }
2217                         break;
2218                 default:
2219                         ASSERT(false);
2220                 }
2221         }
2222
2223         void PixelRoutine::rasterOperation(Vector4f oC[4], Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
2224         {
2225                 for(int index = 0; index < 4; index++)
2226                 {
2227                         if(!state.colorWriteActive(index))
2228                         {
2229                                 continue;
2230                         }
2231
2232                         if(!postBlendSRGB && state.writeSRGB)
2233                         {
2234                                 oC[index].x = linearToSRGB(oC[index].x);
2235                                 oC[index].y = linearToSRGB(oC[index].y);
2236                                 oC[index].z = linearToSRGB(oC[index].z);
2237                         }
2238
2239                         if(index == 0)
2240                         {
2241                                 fogBlend(r, oC[index], fog, r.z[0], r.rhw);
2242                         }
2243
2244                         switch(state.targetFormat[index])
2245                         {
2246                         case FORMAT_X8R8G8B8:
2247                         case FORMAT_X8B8G8R8:
2248                         case FORMAT_A8R8G8B8:
2249                         case FORMAT_A8B8G8R8:
2250                         case FORMAT_A8:
2251                         case FORMAT_G16R16:
2252                         case FORMAT_A16B16G16R16:
2253                                 for(unsigned int q = 0; q < state.multiSample; q++)
2254                                 {
2255                                         Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[index]));
2256                                         Vector4s color;
2257
2258                                         color.x = convertFixed16(oC[index].x, false);
2259                                         color.y = convertFixed16(oC[index].y, false);
2260                                         color.z = convertFixed16(oC[index].z, false);
2261                                         color.w = convertFixed16(oC[index].w, false);
2262
2263                                         if(state.multiSampleMask & (1 << q))
2264                                         {
2265                                                 alphaBlend(r, index, buffer, color, x);
2266                                                 writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
2267                                         }
2268                                 }
2269                                 break;
2270                         case FORMAT_R32F:
2271                         case FORMAT_G32R32F:
2272                         case FORMAT_A32B32G32R32F:
2273                                 for(unsigned int q = 0; q < state.multiSample; q++)
2274                                 {
2275                                         Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[index]));
2276                                         Vector4f color = oC[index];
2277
2278                                         if(state.multiSampleMask & (1 << q))
2279                                         {
2280                                                 alphaBlend(r, index, buffer, color, x);
2281                                                 writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
2282                                         }
2283                                 }
2284                                 break;
2285                         default:
2286                                 ASSERT(false);
2287                         }
2288                 }
2289         }
2290
2291         void PixelRoutine::blendFactor(Registers &r, const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive)
2292         {
2293                 switch(blendFactorActive)
2294                 {
2295                 case BLEND_ZERO:
2296                         // Optimized
2297                         break;
2298                 case BLEND_ONE:
2299                         // Optimized
2300                         break;
2301                 case BLEND_SOURCE:
2302                         blendFactor.x = current.x;
2303                         blendFactor.y = current.y;
2304                         blendFactor.z = current.z;
2305                         break;
2306                 case BLEND_INVSOURCE:
2307                         blendFactor.x = Short4(0xFFFFu) - current.x;
2308                         blendFactor.y = Short4(0xFFFFu) - current.y;
2309                         blendFactor.z = Short4(0xFFFFu) - current.z;
2310                         break;
2311                 case BLEND_DEST:
2312                         blendFactor.x = pixel.x;
2313                         blendFactor.y = pixel.y;
2314                         blendFactor.z = pixel.z;
2315                         break;
2316                 case BLEND_INVDEST:
2317                         blendFactor.x = Short4(0xFFFFu) - pixel.x;
2318                         blendFactor.y = Short4(0xFFFFu) - pixel.y;
2319                         blendFactor.z = Short4(0xFFFFu) - pixel.z;
2320                         break;
2321                 case BLEND_SOURCEALPHA:
2322                         blendFactor.x = current.w;
2323                         blendFactor.y = current.w;
2324                         blendFactor.z = current.w;
2325                         break;
2326                 case BLEND_INVSOURCEALPHA:
2327                         blendFactor.x = Short4(0xFFFFu) - current.w;
2328                         blendFactor.y = Short4(0xFFFFu) - current.w;
2329                         blendFactor.z = Short4(0xFFFFu) - current.w;
2330                         break;
2331                 case BLEND_DESTALPHA:
2332                         blendFactor.x = pixel.w;
2333                         blendFactor.y = pixel.w;
2334                         blendFactor.z = pixel.w;
2335                         break;
2336                 case BLEND_INVDESTALPHA:
2337                         blendFactor.x = Short4(0xFFFFu) - pixel.w;
2338                         blendFactor.y = Short4(0xFFFFu) - pixel.w;
2339                         blendFactor.z = Short4(0xFFFFu) - pixel.w;
2340                         break;
2341                 case BLEND_SRCALPHASAT:
2342                         blendFactor.x = Short4(0xFFFFu) - pixel.w;
2343                         blendFactor.x = Min(As<UShort4>(blendFactor.x), As<UShort4>(current.w));
2344                         blendFactor.y = blendFactor.x;
2345                         blendFactor.z = blendFactor.x;
2346                         break;
2347                 case BLEND_CONSTANT:
2348                         blendFactor.x = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[0]));
2349                         blendFactor.y = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[1]));
2350                         blendFactor.z = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[2]));
2351                         break;
2352                 case BLEND_INVCONSTANT:
2353                         blendFactor.x = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[0]));
2354                         blendFactor.y = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[1]));
2355                         blendFactor.z = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[2]));
2356                         break;
2357                 case BLEND_CONSTANTALPHA:
2358                         blendFactor.x = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
2359                         blendFactor.y = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
2360                         blendFactor.z = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
2361                         break;
2362                 case BLEND_INVCONSTANTALPHA:
2363                         blendFactor.x = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
2364                         blendFactor.y = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
2365                         blendFactor.z = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
2366                         break;
2367                 default:
2368                         ASSERT(false);
2369                 }
2370         }
2371
2372         void PixelRoutine::blendFactorAlpha(Registers &r, const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive)
2373         {
2374                 switch(blendFactorAlphaActive)
2375                 {
2376                 case BLEND_ZERO:
2377                         // Optimized
2378                         break;
2379                 case BLEND_ONE:
2380                         // Optimized
2381                         break;
2382                 case BLEND_SOURCE:
2383                         blendFactor.w = current.w;
2384                         break;
2385                 case BLEND_INVSOURCE:
2386                         blendFactor.w = Short4(0xFFFFu) - current.w;
2387                         break;
2388                 case BLEND_DEST:
2389                         blendFactor.w = pixel.w;
2390                         break;
2391                 case BLEND_INVDEST:
2392                         blendFactor.w = Short4(0xFFFFu) - pixel.w;
2393                         break;
2394                 case BLEND_SOURCEALPHA:
2395                         blendFactor.w = current.w;
2396                         break;
2397                 case BLEND_INVSOURCEALPHA:
2398                         blendFactor.w = Short4(0xFFFFu) - current.w;
2399                         break;
2400                 case BLEND_DESTALPHA:
2401                         blendFactor.w = pixel.w;
2402                         break;
2403                 case BLEND_INVDESTALPHA:
2404                         blendFactor.w = Short4(0xFFFFu) - pixel.w;
2405                         break;
2406                 case BLEND_SRCALPHASAT:
2407                         blendFactor.w = Short4(0xFFFFu);
2408                         break;
2409                 case BLEND_CONSTANT:
2410                 case BLEND_CONSTANTALPHA:
2411                         blendFactor.w = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
2412                         break;
2413                 case BLEND_INVCONSTANT:
2414                 case BLEND_INVCONSTANTALPHA:
2415                         blendFactor.w = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
2416                         break;
2417                 default:
2418                         ASSERT(false);
2419                 }
2420         }
2421
2422         void PixelRoutine::alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x)
2423         {
2424                 if(!state.alphaBlendActive)
2425                 {
2426                         return;
2427                 }
2428
2429                 Pointer<Byte> buffer;
2430
2431                 Vector4s pixel;
2432                 Short4 c01;
2433                 Short4 c23;
2434
2435                 // Read pixel
2436                 switch(state.targetFormat[index])
2437                 {
2438                 case FORMAT_A8R8G8B8:
2439                         buffer = cBuffer + 4 * x;
2440                         c01 = *Pointer<Short4>(buffer);
2441                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2442                         c23 = *Pointer<Short4>(buffer);
2443                         pixel.z = c01;
2444                         pixel.y = c01;
2445                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
2446                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
2447                         pixel.x = pixel.z;
2448                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
2449                         pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
2450                         pixel.y = pixel.z;
2451                         pixel.w = pixel.x;
2452                         pixel.x = UnpackLow(As<Byte8>(pixel.x), As<Byte8>(pixel.x));
2453                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
2454                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
2455                         pixel.w = UnpackHigh(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
2456                         break;
2457                 case FORMAT_A8B8G8R8:
2458                         buffer = cBuffer + 4 * x;
2459                         c01 = *Pointer<Short4>(buffer);
2460                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2461                         c23 = *Pointer<Short4>(buffer);
2462                         pixel.z = c01;
2463                         pixel.y = c01;
2464                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
2465                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
2466                         pixel.x = pixel.z;
2467                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
2468                         pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
2469                         pixel.y = pixel.z;
2470                         pixel.w = pixel.x;
2471                         pixel.x = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
2472                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
2473                         pixel.z = UnpackLow(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
2474                         pixel.w = UnpackHigh(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
2475                         break;
2476                 case FORMAT_A8:
2477                         buffer = cBuffer + 1 * x;
2478                         pixel.w = Insert(pixel.w, *Pointer<Short>(buffer), 0);
2479                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2480                         pixel.w = Insert(pixel.w, *Pointer<Short>(buffer), 1);
2481                         pixel.w = UnpackLow(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
2482                         pixel.x = Short4(0x0000);
2483                         pixel.y = Short4(0x0000);
2484                         pixel.z = Short4(0x0000);
2485                         break;
2486                 case FORMAT_X8R8G8B8:
2487                         buffer = cBuffer + 4 * x;
2488                         c01 = *Pointer<Short4>(buffer);
2489                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2490                         c23 = *Pointer<Short4>(buffer);
2491                         pixel.z = c01;
2492                         pixel.y = c01;
2493                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
2494                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
2495                         pixel.x = pixel.z;
2496                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
2497                         pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
2498                         pixel.y = pixel.z;
2499                         pixel.x = UnpackLow(As<Byte8>(pixel.x), As<Byte8>(pixel.x));
2500                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
2501                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
2502                         pixel.w = Short4(0xFFFFu);
2503                         break;
2504                 case FORMAT_X8B8G8R8:
2505                         buffer = cBuffer + 4 * x;
2506                         c01 = *Pointer<Short4>(buffer);
2507                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2508                         c23 = *Pointer<Short4>(buffer);
2509                         pixel.z = c01;
2510                         pixel.y = c01;
2511                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
2512                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
2513                         pixel.x = pixel.z;
2514                         pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
2515                         pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
2516                         pixel.y = pixel.z;
2517                         pixel.w = pixel.x;
2518                         pixel.x = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
2519                         pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
2520                         pixel.z = UnpackLow(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
2521                         pixel.w = Short4(0xFFFFu);
2522                         break;
2523                 case FORMAT_A8G8R8B8Q:
2524                         UNIMPLEMENTED();
2525                 //      pixel.z = UnpackLow(As<Byte8>(pixel.z), *Pointer<Byte8>(cBuffer + 8 * x + 0));
2526                 //      pixel.x = UnpackHigh(As<Byte8>(pixel.x), *Pointer<Byte8>(cBuffer + 8 * x + 0));
2527                 //      pixel.y = UnpackLow(As<Byte8>(pixel.y), *Pointer<Byte8>(cBuffer + 8 * x + 8));
2528                 //      pixel.w = UnpackHigh(As<Byte8>(pixel.w), *Pointer<Byte8>(cBuffer + 8 * x + 8));
2529                         break;
2530                 case FORMAT_X8G8R8B8Q:
2531                         UNIMPLEMENTED();
2532                 //      pixel.z = UnpackLow(As<Byte8>(pixel.z), *Pointer<Byte8>(cBuffer + 8 * x + 0));
2533                 //      pixel.x = UnpackHigh(As<Byte8>(pixel.x), *Pointer<Byte8>(cBuffer + 8 * x + 0));
2534                 //      pixel.y = UnpackLow(As<Byte8>(pixel.y), *Pointer<Byte8>(cBuffer + 8 * x + 8));
2535                 //      pixel.w = Short4(0xFFFFu);
2536                         break;
2537                 case FORMAT_A16B16G16R16:
2538                         buffer  = cBuffer;
2539                         pixel.x = *Pointer<Short4>(buffer + 8 * x);
2540                         pixel.y = *Pointer<Short4>(buffer + 8 * x + 8);
2541                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2542                         pixel.z = *Pointer<Short4>(buffer + 8 * x);
2543                         pixel.w = *Pointer<Short4>(buffer + 8 * x + 8);
2544                         transpose4x4(pixel.x, pixel.y, pixel.z, pixel.w);
2545                         break;
2546                 case FORMAT_G16R16:
2547                         buffer = cBuffer;
2548                         pixel.x = *Pointer<Short4>(buffer  + 4 * x);
2549                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2550                         pixel.y = *Pointer<Short4>(buffer  + 4 * x);
2551                         pixel.z = pixel.x;
2552                         pixel.x = As<Short4>(UnpackLow(pixel.x, pixel.y));
2553                         pixel.z = As<Short4>(UnpackHigh(pixel.z, pixel.y));
2554                         pixel.y = pixel.z;
2555                         pixel.x = As<Short4>(UnpackLow(pixel.x, pixel.z));
2556                         pixel.y = As<Short4>(UnpackHigh(pixel.y, pixel.z));
2557                         pixel.z = Short4(0xFFFFu);
2558                         pixel.w = Short4(0xFFFFu);
2559                         break;
2560                 default:
2561                         ASSERT(false);
2562                 }
2563
2564                 if(postBlendSRGB && state.writeSRGB)
2565                 {
2566                         sRGBtoLinear16_16(r, pixel);
2567                 }
2568
2569                 // Final Color = ObjectColor * SourceBlendFactor + PixelColor * DestinationBlendFactor
2570                 Vector4s sourceFactor;
2571                 Vector4s destFactor;
2572
2573                 blendFactor(r, sourceFactor, current, pixel, state.sourceBlendFactor);
2574                 blendFactor(r, destFactor, current, pixel, state.destBlendFactor);
2575
2576                 if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
2577                 {
2578                         current.x = MulHigh(As<UShort4>(current.x), As<UShort4>(sourceFactor.x));
2579                         current.y = MulHigh(As<UShort4>(current.y), As<UShort4>(sourceFactor.y));
2580                         current.z = MulHigh(As<UShort4>(current.z), As<UShort4>(sourceFactor.z));
2581                 }
2582
2583                 if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
2584                 {
2585                         pixel.x = MulHigh(As<UShort4>(pixel.x), As<UShort4>(destFactor.x));
2586                         pixel.y = MulHigh(As<UShort4>(pixel.y), As<UShort4>(destFactor.y));
2587                         pixel.z = MulHigh(As<UShort4>(pixel.z), As<UShort4>(destFactor.z));
2588                 }
2589
2590                 switch(state.blendOperation)
2591                 {
2592                 case BLENDOP_ADD:
2593                         current.x = AddSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
2594                         current.y = AddSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
2595                         current.z = AddSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
2596                         break;
2597                 case BLENDOP_SUB:
2598                         current.x = SubSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
2599                         current.y = SubSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
2600                         current.z = SubSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
2601                         break;
2602                 case BLENDOP_INVSUB:
2603                         current.x = SubSat(As<UShort4>(pixel.x), As<UShort4>(current.x));
2604                         current.y = SubSat(As<UShort4>(pixel.y), As<UShort4>(current.y));
2605                         current.z = SubSat(As<UShort4>(pixel.z), As<UShort4>(current.z));
2606                         break;
2607                 case BLENDOP_MIN:
2608                         current.x = Min(As<UShort4>(current.x), As<UShort4>(pixel.x));
2609                         current.y = Min(As<UShort4>(current.y), As<UShort4>(pixel.y));
2610                         current.z = Min(As<UShort4>(current.z), As<UShort4>(pixel.z));
2611                         break;
2612                 case BLENDOP_MAX:
2613                         current.x = Max(As<UShort4>(current.x), As<UShort4>(pixel.x));
2614                         current.y = Max(As<UShort4>(current.y), As<UShort4>(pixel.y));
2615                         current.z = Max(As<UShort4>(current.z), As<UShort4>(pixel.z));
2616                         break;
2617                 case BLENDOP_SOURCE:
2618                         // No operation
2619                         break;
2620                 case BLENDOP_DEST:
2621                         current.x = pixel.x;
2622                         current.y = pixel.y;
2623                         current.z = pixel.z;
2624                         break;
2625                 case BLENDOP_NULL:
2626                         current.x = Short4(0x0000, 0x0000, 0x0000, 0x0000);
2627                         current.y = Short4(0x0000, 0x0000, 0x0000, 0x0000);
2628                         current.z = Short4(0x0000, 0x0000, 0x0000, 0x0000);
2629                         break;
2630                 default:
2631                         ASSERT(false);
2632                 }
2633
2634                 blendFactorAlpha(r, sourceFactor, current, pixel, state.sourceBlendFactorAlpha);
2635                 blendFactorAlpha(r, destFactor, current, pixel, state.destBlendFactorAlpha);
2636
2637                 if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
2638                 {
2639                         current.w = MulHigh(As<UShort4>(current.w), As<UShort4>(sourceFactor.w));
2640                 }
2641
2642                 if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
2643                 {
2644                         pixel.w = MulHigh(As<UShort4>(pixel.w), As<UShort4>(destFactor.w));
2645                 }
2646
2647                 switch(state.blendOperationAlpha)
2648                 {
2649                 case BLENDOP_ADD:
2650                         current.w = AddSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
2651                         break;
2652                 case BLENDOP_SUB:
2653                         current.w = SubSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
2654                         break;
2655                 case BLENDOP_INVSUB:
2656                         current.w = SubSat(As<UShort4>(pixel.w), As<UShort4>(current.w));
2657                         break;
2658                 case BLENDOP_MIN:
2659                         current.w = Min(As<UShort4>(current.w), As<UShort4>(pixel.w));
2660                         break;
2661                 case BLENDOP_MAX:
2662                         current.w = Max(As<UShort4>(current.w), As<UShort4>(pixel.w));
2663                         break;
2664                 case BLENDOP_SOURCE:
2665                         // No operation
2666                         break;
2667                 case BLENDOP_DEST:
2668                         current.w = pixel.w;
2669                         break;
2670                 case BLENDOP_NULL:
2671                         current.w = Short4(0x0000, 0x0000, 0x0000, 0x0000);
2672                         break;
2673                 default:
2674                         ASSERT(false);
2675                 }
2676         }
2677
2678         void PixelRoutine::writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &current, Int &sMask, Int &zMask, Int &cMask)
2679         {
2680                 if(!state.colorWriteActive(index))
2681                 {
2682                         return;
2683                 }
2684
2685                 if(postBlendSRGB && state.writeSRGB)
2686                 {
2687                         linearToSRGB16_16(r, current);
2688                 }
2689
2690                 if(exactColorRounding)
2691                 {
2692                         switch(state.targetFormat[index])
2693                         {
2694                         case FORMAT_X8G8R8B8Q:
2695                         case FORMAT_A8G8R8B8Q:
2696                         case FORMAT_X8R8G8B8:
2697                         case FORMAT_X8B8G8R8:
2698                         case FORMAT_A8R8G8B8:
2699                         case FORMAT_A8B8G8R8:
2700                                 {
2701                                         current.x = current.x - As<Short4>(As<UShort4>(current.x) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
2702                                         current.y = current.y - As<Short4>(As<UShort4>(current.y) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
2703                                         current.z = current.z - As<Short4>(As<UShort4>(current.z) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
2704                                         current.w = current.w - As<Short4>(As<UShort4>(current.w) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
2705                                 }
2706                                 break;
2707                         }
2708                 }
2709
2710                 int rgbaWriteMask = state.colorWriteActive(index);
2711                 int bgraWriteMask = rgbaWriteMask & 0x0000000A | (rgbaWriteMask & 0x00000001) << 2 | (rgbaWriteMask & 0x00000004) >> 2;
2712                 int brgaWriteMask = rgbaWriteMask & 0x00000008 | (rgbaWriteMask & 0x00000001) << 1 | (rgbaWriteMask & 0x00000002) << 1 | (rgbaWriteMask & 0x00000004) >> 2;
2713
2714                 switch(state.targetFormat[index])
2715                 {
2716                 case FORMAT_X8G8R8B8Q:
2717                         UNIMPLEMENTED();
2718                 //      current.x = As<Short4>(As<UShort4>(current.x) >> 8);
2719                 //      current.y = As<Short4>(As<UShort4>(current.y) >> 8);
2720                 //      current.z = As<Short4>(As<UShort4>(current.z) >> 8);
2721
2722                 //      current.z = As<Short4>(Pack(As<UShort4>(current.z), As<UShort4>(current.x)));
2723                 //      current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.y)));
2724                         break;
2725                 case FORMAT_A8G8R8B8Q:
2726                         UNIMPLEMENTED();
2727                 //      current.x = As<Short4>(As<UShort4>(current.x) >> 8);
2728                 //      current.y = As<Short4>(As<UShort4>(current.y) >> 8);
2729                 //      current.z = As<Short4>(As<UShort4>(current.z) >> 8);
2730                 //      current.w = As<Short4>(As<UShort4>(current.w) >> 8);
2731
2732                 //      current.z = As<Short4>(Pack(As<UShort4>(current.z), As<UShort4>(current.x)));
2733                 //      current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.w)));
2734                         break;
2735                 case FORMAT_X8R8G8B8:
2736                 case FORMAT_A8R8G8B8:
2737                         if(state.targetFormat[index] == FORMAT_X8R8G8B8 || rgbaWriteMask == 0x7)
2738                         {
2739                                 current.x = As<Short4>(As<UShort4>(current.x) >> 8);
2740                                 current.y = As<Short4>(As<UShort4>(current.y) >> 8);
2741                                 current.z = As<Short4>(As<UShort4>(current.z) >> 8);
2742
2743                                 current.z = As<Short4>(Pack(As<UShort4>(current.z), As<UShort4>(current.x)));
2744                                 current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.y)));
2745
2746                                 current.x = current.z;
2747                                 current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
2748                                 current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
2749                                 current.y = current.z;
2750                                 current.z = As<Short4>(UnpackLow(current.z, current.x));
2751                                 current.y = As<Short4>(UnpackHigh(current.y, current.x));
2752                         }
2753                         else
2754                         {
2755                                 current.x = As<Short4>(As<UShort4>(current.x) >> 8);
2756                                 current.y = As<Short4>(As<UShort4>(current.y) >> 8);
2757                                 current.z = As<Short4>(As<UShort4>(current.z) >> 8);
2758                                 current.w = As<Short4>(As<UShort4>(current.w) >> 8);
2759
2760                                 current.z = As<Short4>(Pack(As<UShort4>(current.z), As<UShort4>(current.x)));
2761                                 current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.w)));
2762
2763                                 current.x = current.z;
2764                                 current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
2765                                 current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
2766                                 current.y = current.z;
2767                                 current.z = As<Short4>(UnpackLow(current.z, current.x));
2768                                 current.y = As<Short4>(UnpackHigh(current.y, current.x));
2769                         }
2770                         break;
2771                 case FORMAT_X8B8G8R8:
2772                 case FORMAT_A8B8G8R8:
2773                         if(state.targetFormat[index] == FORMAT_X8B8G8R8 || rgbaWriteMask == 0x7)
2774                         {
2775                                 current.x = As<Short4>(As<UShort4>(current.x) >> 8);
2776                                 current.y = As<Short4>(As<UShort4>(current.y) >> 8);
2777                                 current.z = As<Short4>(As<UShort4>(current.z) >> 8);
2778
2779                                 current.z = As<Short4>(Pack(As<UShort4>(current.x), As<UShort4>(current.z)));
2780                                 current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.y)));
2781
2782                                 current.x = current.z;
2783                                 current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
2784                                 current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
2785                                 current.y = current.z;
2786                                 current.z = As<Short4>(UnpackLow(current.z, current.x));
2787                                 current.y = As<Short4>(UnpackHigh(current.y, current.x));
2788                         }
2789                         else
2790                         {
2791                                 current.x = As<Short4>(As<UShort4>(current.x) >> 8);
2792                                 current.y = As<Short4>(As<UShort4>(current.y) >> 8);
2793                                 current.z = As<Short4>(As<UShort4>(current.z) >> 8);
2794                                 current.w = As<Short4>(As<UShort4>(current.w) >> 8);
2795
2796                                 current.z = As<Short4>(Pack(As<UShort4>(current.x), As<UShort4>(current.z)));
2797                                 current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.w)));
2798
2799                                 current.x = current.z;
2800                                 current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
2801                                 current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
2802                                 current.y = current.z;
2803                                 current.z = As<Short4>(UnpackLow(current.z, current.x));
2804                                 current.y = As<Short4>(UnpackHigh(current.y, current.x));
2805                         }
2806                         break;
2807                 case FORMAT_A8:
2808                         current.w = As<Short4>(As<UShort4>(current.w) >> 8);
2809                         current.w = As<Short4>(Pack(As<UShort4>(current.w), As<UShort4>(current.w)));
2810                         break;
2811                 case FORMAT_G16R16:
2812                         current.z = current.x;
2813                         current.x = As<Short4>(UnpackLow(current.x, current.y));
2814                         current.z = As<Short4>(UnpackHigh(current.z, current.y));
2815                         current.y = current.z;
2816                         break;
2817                 case FORMAT_A16B16G16R16:
2818                         transpose4x4(current.x, current.y, current.z, current.w);
2819                         break;
2820                 case FORMAT_R32F:
2821                 case FORMAT_G32R32F:
2822                 case FORMAT_A32B32G32R32F:
2823                         {
2824                                 Vector4f oC;
2825
2826                                 oC.x = convertUnsigned16(UShort4(current.x));
2827                                 oC.y = convertUnsigned16(UShort4(current.y));
2828                                 oC.z = convertUnsigned16(UShort4(current.z));
2829                                 oC.w = convertUnsigned16(UShort4(current.w));
2830
2831                                 writeColor(r, index, cBuffer, x, oC, sMask, zMask, cMask);
2832                         }
2833                         return;
2834                 default:
2835                         ASSERT(false);
2836                 }
2837
2838                 Short4 c01 = current.z;
2839                 Short4 c23 = current.y;
2840
2841                 Int xMask;   // Combination of all masks
2842
2843                 if(state.depthTestActive)
2844                 {
2845                         xMask = zMask;
2846                 }
2847                 else
2848                 {
2849                         xMask = cMask;
2850                 }
2851
2852                 if(state.stencilActive)
2853                 {
2854                         xMask &= sMask;
2855                 }
2856
2857                 Pointer<Byte> buffer;
2858                 Short4 value;
2859
2860                 switch(state.targetFormat[index])
2861                 {
2862                 case FORMAT_A8G8R8B8Q:
2863                 case FORMAT_X8G8R8B8Q:   // FIXME: Don't touch alpha?
2864                         UNIMPLEMENTED();
2865                 //      value = *Pointer<Short4>(cBuffer + 8 * x + 0);
2866
2867                 //      if((state.targetFormat[index] == FORMAT_A8G8R8B8Q && bgraWriteMask != 0x0000000F) ||
2868                 //         ((state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x00000007) &&
2869                 //          (state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
2870                 //      {
2871                 //              Short4 masked = value;
2872                 //              c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
2873                 //              masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
2874                 //              c01 |= masked;
2875                 //      }
2876
2877                 //      c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD01Q) + xMask * 8);
2878                 //      value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
2879                 //      c01 |= value;
2880                 //      *Pointer<Short4>(cBuffer + 8 * x + 0) = c01;
2881
2882                 //      value = *Pointer<Short4>(cBuffer + 8 * x + 8);
2883
2884                 //      if((state.targetFormat[index] == FORMAT_A8G8R8B8Q && bgraWriteMask != 0x0000000F) ||
2885                 //         ((state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x00000007) &&
2886                 //          (state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
2887                 //      {
2888                 //              Short4 masked = value;
2889                 //              c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
2890                 //              masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
2891                 //              c23 |= masked;
2892                 //      }
2893
2894                 //      c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD23Q) + xMask * 8);
2895                 //      value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
2896                 //      c23 |= value;
2897                 //      *Pointer<Short4>(cBuffer + 8 * x + 8) = c23;
2898                         break;
2899                 case FORMAT_A8R8G8B8:
2900                 case FORMAT_X8R8G8B8:   // FIXME: Don't touch alpha?
2901                         buffer = cBuffer + x * 4;
2902                         value = *Pointer<Short4>(buffer);
2903
2904                         if((state.targetFormat[index] == FORMAT_A8R8G8B8 && bgraWriteMask != 0x0000000F) ||
2905                            ((state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x00000007) &&
2906                             (state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
2907                         {
2908                                 Short4 masked = value;
2909                                 c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
2910                                 masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
2911                                 c01 |= masked;
2912                         }
2913
2914                         c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD01Q) + xMask * 8);
2915                         value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
2916                         c01 |= value;
2917                         *Pointer<Short4>(buffer) = c01;
2918
2919                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2920                         value = *Pointer<Short4>(buffer);
2921
2922                         if((state.targetFormat[index] == FORMAT_A8R8G8B8 && bgraWriteMask != 0x0000000F) ||
2923                            ((state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x00000007) &&
2924                             (state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
2925                         {
2926                                 Short4 masked = value;
2927                                 c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
2928                                 masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
2929                                 c23 |= masked;
2930                         }
2931
2932                         c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD23Q) + xMask * 8);
2933                         value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
2934                         c23 |= value;
2935                         *Pointer<Short4>(buffer) = c23;
2936                         break;
2937                 case FORMAT_A8B8G8R8:
2938                 case FORMAT_X8B8G8R8:   // FIXME: Don't touch alpha?
2939                         buffer = cBuffer + x * 4;
2940                         value = *Pointer<Short4>(buffer);
2941
2942                         if((state.targetFormat[index] == FORMAT_A8B8G8R8 && rgbaWriteMask != 0x0000000F) ||
2943                            ((state.targetFormat[index] == FORMAT_X8B8G8R8 && rgbaWriteMask != 0x00000007) &&
2944                             (state.targetFormat[index] == FORMAT_X8B8G8R8 && rgbaWriteMask != 0x0000000F)))   // FIXME: Need for masking when XBGR && Fh?
2945                         {
2946                                 Short4 masked = value;
2947                                 c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[rgbaWriteMask][0]));
2948                                 masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[rgbaWriteMask][0]));
2949                                 c01 |= masked;
2950                         }
2951
2952                         c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD01Q) + xMask * 8);
2953                         value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
2954                         c01 |= value;
2955                         *Pointer<Short4>(buffer) = c01;
2956
2957                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2958                         value = *Pointer<Short4>(buffer);
2959
2960                         if((state.targetFormat[index] == FORMAT_A8B8G8R8 && rgbaWriteMask != 0x0000000F) ||
2961                            ((state.targetFormat[index] == FORMAT_X8B8G8R8 && rgbaWriteMask != 0x00000007) &&
2962                             (state.targetFormat[index] == FORMAT_X8B8G8R8 && rgbaWriteMask != 0x0000000F)))   // FIXME: Need for masking when XBGR && Fh?
2963                         {
2964                                 Short4 masked = value;
2965                                 c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[rgbaWriteMask][0]));
2966                                 masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[rgbaWriteMask][0]));
2967                                 c23 |= masked;
2968                         }
2969
2970                         c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD23Q) + xMask * 8);
2971                         value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
2972                         c23 |= value;
2973                         *Pointer<Short4>(buffer) = c23;
2974                         break;
2975                 case FORMAT_A8:
2976                         if(rgbaWriteMask & 0x00000008)
2977                         {
2978                                 buffer = cBuffer + 1 * x;
2979                                 Insert(value, *Pointer<Short>(buffer), 0);
2980                                 Int pitch = *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
2981                                 Insert(value, *Pointer<Short>(buffer + pitch), 1);
2982                                 value = UnpackLow(As<Byte8>(value), As<Byte8>(value));
2983
2984                                 current.w &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q) + 8 * xMask);
2985                                 value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q) + 8 * xMask);
2986                                 current.w |= value;
2987
2988                                 *Pointer<Short>(buffer) = Extract(current.w, 0);
2989                                 *Pointer<Short>(buffer + pitch) = Extract(current.w, 1);
2990                         }
2991                         break;
2992                 case FORMAT_G16R16:
2993                         buffer = cBuffer + 4 * x;
2994
2995                         value = *Pointer<Short4>(buffer);
2996
2997                         if((rgbaWriteMask & 0x00000003) != 0x00000003)
2998                         {
2999                                 Short4 masked = value;
3000                                 current.x &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW01Q[rgbaWriteMask & 0x3][0]));
3001                                 masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW01Q[rgbaWriteMask & 0x3][0]));
3002                                 current.x |= masked;
3003                         }
3004
3005                         current.x &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD01Q) + xMask * 8);
3006                         value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
3007                         current.x |= value;
3008                         *Pointer<Short4>(buffer) = current.x;
3009
3010                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3011
3012                         value = *Pointer<Short4>(buffer);
3013
3014                         if((rgbaWriteMask & 0x00000003) != 0x00000003)
3015                         {
3016                                 Short4 masked = value;
3017                                 current.y &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW01Q[rgbaWriteMask & 0x3][0]));
3018                                 masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW01Q[rgbaWriteMask & 0x3][0]));
3019                                 current.y |= masked;
3020                         }
3021
3022                         current.y &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD23Q) + xMask * 8);
3023                         value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
3024                         current.y |= value;
3025                         *Pointer<Short4>(buffer) = current.y;
3026                         break;
3027                 case FORMAT_A16B16G16R16:
3028                         buffer = cBuffer + 8 * x;
3029
3030                         {
3031                                 value = *Pointer<Short4>(buffer);
3032
3033                                 if(rgbaWriteMask != 0x0000000F)
3034                                 {
3035                                         Short4 masked = value;
3036                                         current.x &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
3037                                         masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
3038                                         current.x |= masked;
3039                                 }
3040
3041                                 current.x &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ0Q) + xMask * 8);
3042                                 value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ0Q) + xMask * 8);
3043                                 current.x |= value;
3044                                 *Pointer<Short4>(buffer) = current.x;
3045                         }
3046
3047                         {
3048                                 value = *Pointer<Short4>(buffer + 8);
3049
3050                                 if(rgbaWriteMask != 0x0000000F)
3051                                 {
3052                                         Short4 masked = value;
3053                                         current.y &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
3054                                         masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
3055                                         current.y |= masked;
3056                                 }
3057
3058                                 current.y &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ1Q) + xMask * 8);
3059                                 value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ1Q) + xMask * 8);
3060                                 current.y |= value;
3061                                 *Pointer<Short4>(buffer + 8) = current.y;
3062                         }
3063
3064                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3065
3066                         {
3067                                 value = *Pointer<Short4>(buffer);
3068
3069                                 if(rgbaWriteMask != 0x0000000F)
3070                                 {
3071                                         Short4 masked = value;
3072                                         current.z &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
3073                                         masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
3074                                         current.z |= masked;
3075                                 }
3076
3077                                 current.z &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ2Q) + xMask * 8);
3078                                 value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ2Q) + xMask * 8);
3079                                 current.z |= value;
3080                                 *Pointer<Short4>(buffer) = current.z;
3081                         }
3082
3083                         {
3084                                 value = *Pointer<Short4>(buffer + 8);
3085
3086                                 if(rgbaWriteMask != 0x0000000F)
3087                                 {
3088                                         Short4 masked = value;
3089                                         current.w &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
3090                                         masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
3091                                         current.w |= masked;
3092                                 }
3093
3094                                 current.w &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ3Q) + xMask * 8);
3095                                 value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ3Q) + xMask * 8);
3096                                 current.w |= value;
3097                                 *Pointer<Short4>(buffer + 8) = current.w;
3098                         }
3099                         break;
3100                 default:
3101                         ASSERT(false);
3102                 }
3103         }
3104
3105         void PixelRoutine::blendFactor(Registers &r, const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive)
3106         {
3107                 switch(blendFactorActive)
3108                 {
3109                 case BLEND_ZERO:
3110                         // Optimized
3111                         break;
3112                 case BLEND_ONE:
3113                         // Optimized
3114                         break;
3115                 case BLEND_SOURCE:
3116                         blendFactor.x = oC.x;
3117                         blendFactor.y = oC.y;
3118                         blendFactor.z = oC.z;
3119                         break;
3120                 case BLEND_INVSOURCE:
3121                         blendFactor.x = Float4(1.0f) - oC.x;
3122                         blendFactor.y = Float4(1.0f) - oC.y;
3123                         blendFactor.z = Float4(1.0f) - oC.z;
3124                         break;
3125                 case BLEND_DEST:
3126                         blendFactor.x = pixel.x;
3127                         blendFactor.y = pixel.y;
3128                         blendFactor.z = pixel.z;
3129                         break;
3130                 case BLEND_INVDEST:
3131                         blendFactor.x = Float4(1.0f) - pixel.x;
3132                         blendFactor.y = Float4(1.0f) - pixel.y;
3133                         blendFactor.z = Float4(1.0f) - pixel.z;
3134                         break;
3135                 case BLEND_SOURCEALPHA:
3136                         blendFactor.x = oC.w;
3137                         blendFactor.y = oC.w;
3138                         blendFactor.z = oC.w;
3139                         break;
3140                 case BLEND_INVSOURCEALPHA:
3141                         blendFactor.x = Float4(1.0f) - oC.w;
3142                         blendFactor.y = Float4(1.0f) - oC.w;
3143                         blendFactor.z = Float4(1.0f) - oC.w;
3144                         break;
3145                 case BLEND_DESTALPHA:
3146                         blendFactor.x = pixel.w;
3147                         blendFactor.y = pixel.w;
3148                         blendFactor.z = pixel.w;
3149                         break;
3150                 case BLEND_INVDESTALPHA:
3151                         blendFactor.x = Float4(1.0f) - pixel.w;
3152                         blendFactor.y = Float4(1.0f) - pixel.w;
3153                         blendFactor.z = Float4(1.0f) - pixel.w;
3154                         break;
3155                 case BLEND_SRCALPHASAT:
3156                         blendFactor.x = Float4(1.0f) - pixel.w;
3157                         blendFactor.x = Min(blendFactor.x, oC.w);
3158                         blendFactor.y = blendFactor.x;
3159                         blendFactor.z = blendFactor.x;
3160                         break;
3161                 case BLEND_CONSTANT:
3162                         blendFactor.x = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[0]));
3163                         blendFactor.y = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[1]));
3164                         blendFactor.z = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[2]));
3165                         break;
3166                 case BLEND_INVCONSTANT:
3167                         blendFactor.x = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[0]));
3168                         blendFactor.y = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[1]));
3169                         blendFactor.z = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[2]));
3170                         break;
3171                 default:
3172                         ASSERT(false);
3173                 }
3174         }
3175
3176         void PixelRoutine::blendFactorAlpha(Registers &r, const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive)
3177         {
3178                 switch(blendFactorAlphaActive)
3179                 {
3180                 case BLEND_ZERO:
3181                         // Optimized
3182                         break;
3183                 case BLEND_ONE:
3184                         // Optimized
3185                         break;
3186                 case BLEND_SOURCE:
3187                         blendFactor.w = oC.w;
3188                         break;
3189                 case BLEND_INVSOURCE:
3190                         blendFactor.w = Float4(1.0f) - oC.w;
3191                         break;
3192                 case BLEND_DEST:
3193                         blendFactor.w = pixel.w;
3194                         break;
3195                 case BLEND_INVDEST:
3196                         blendFactor.w = Float4(1.0f) - pixel.w;
3197                         break;
3198                 case BLEND_SOURCEALPHA:
3199                         blendFactor.w = oC.w;
3200                         break;
3201                 case BLEND_INVSOURCEALPHA:
3202                         blendFactor.w = Float4(1.0f) - oC.w;
3203                         break;
3204                 case BLEND_DESTALPHA:
3205                         blendFactor.w = pixel.w;
3206                         break;
3207                 case BLEND_INVDESTALPHA:
3208                         blendFactor.w = Float4(1.0f) - pixel.w;
3209                         break;
3210                 case BLEND_SRCALPHASAT:
3211                         blendFactor.w = Float4(1.0f);
3212                         break;
3213                 case BLEND_CONSTANT:
3214                         blendFactor.w = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[3]));
3215                         break;
3216                 case BLEND_INVCONSTANT:
3217                         blendFactor.w = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[3]));
3218                         break;
3219                 default:
3220                         ASSERT(false);
3221                 }
3222         }
3223
3224         void PixelRoutine::alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Vector4f &oC, Int &x)
3225         {
3226                 if(!state.alphaBlendActive)
3227                 {
3228                         return;
3229                 }
3230
3231                 Pointer<Byte> buffer;
3232                 Vector4f pixel;
3233
3234                 Vector4s color;
3235                 Short4 c01;
3236                 Short4 c23;
3237
3238                 // Read pixel
3239                 switch(state.targetFormat[index])
3240                 {
3241                 case FORMAT_A8R8G8B8:
3242                         buffer = cBuffer + 4 * x;
3243                         c01 = *Pointer<Short4>(buffer);
3244                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3245                         c23 = *Pointer<Short4>(buffer);
3246                         color.z = c01;
3247                         color.y = c01;
3248                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(c23));
3249                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(c23));
3250                         color.x = color.z;
3251                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.y));
3252                         color.x = UnpackHigh(As<Byte8>(color.x), As<Byte8>(color.y));
3253                         color.y = color.z;
3254                         color.w = color.x;
3255                         color.x = UnpackLow(As<Byte8>(color.x), As<Byte8>(color.x));
3256                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(color.y));
3257                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.z));
3258                         color.w = UnpackHigh(As<Byte8>(color.w), As<Byte8>(color.w));
3259
3260                         pixel.x = convertUnsigned16(As<UShort4>(color.x));
3261                         pixel.y = convertUnsigned16(As<UShort4>(color.y));
3262                         pixel.z = convertUnsigned16(As<UShort4>(color.z));
3263                         pixel.w = convertUnsigned16(As<UShort4>(color.w));
3264                         break;
3265                 case FORMAT_A8B8G8R8:
3266                         buffer = cBuffer + 4 * x;
3267                         c01 = *Pointer<Short4>(buffer);
3268                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3269                         c23 = *Pointer<Short4>(buffer);
3270                         color.z = c01;
3271                         color.y = c01;
3272                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(c23));
3273                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(c23));
3274                         color.x = color.z;
3275                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.y));
3276                         color.x = UnpackHigh(As<Byte8>(color.x), As<Byte8>(color.y));
3277                         color.y = color.z;
3278                         color.w = color.x;
3279                         color.x = UnpackLow(As<Byte8>(color.x), As<Byte8>(color.x));
3280                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(color.y));
3281                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.z));
3282                         color.w = UnpackHigh(As<Byte8>(color.w), As<Byte8>(color.w));
3283
3284                         pixel.x = convertUnsigned16(As<UShort4>(color.z));
3285                         pixel.y = convertUnsigned16(As<UShort4>(color.y));
3286                         pixel.z = convertUnsigned16(As<UShort4>(color.x));
3287                         pixel.w = convertUnsigned16(As<UShort4>(color.w));
3288                         break;
3289                 case FORMAT_X8R8G8B8:
3290                         buffer = cBuffer + 4 * x;
3291                         c01 = *Pointer<Short4>(buffer);
3292                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3293                         c23 = *Pointer<Short4>(buffer);
3294                         color.z = c01;
3295                         color.y = c01;
3296                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(c23));
3297                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(c23));
3298                         color.x = color.z;
3299                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.y));
3300                         color.x = UnpackHigh(As<Byte8>(color.x), As<Byte8>(color.y));
3301                         color.y = color.z;
3302                         color.x = UnpackLow(As<Byte8>(color.x), As<Byte8>(color.x));
3303                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(color.y));
3304                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.z));
3305
3306                         pixel.x = convertUnsigned16(As<UShort4>(color.x));
3307                         pixel.y = convertUnsigned16(As<UShort4>(color.y));
3308                         pixel.z = convertUnsigned16(As<UShort4>(color.z));
3309                         pixel.w = Float4(1.0f);
3310                         break;
3311                 case FORMAT_X8B8G8R8:
3312                         buffer = cBuffer + 4 * x;
3313                         c01 = *Pointer<Short4>(buffer);
3314                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3315                         c23 = *Pointer<Short4>(buffer);
3316                         color.z = c01;
3317                         color.y = c01;
3318                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(c23));
3319                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(c23));
3320                         color.x = color.z;
3321                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.y));
3322                         color.x = UnpackHigh(As<Byte8>(color.x), As<Byte8>(color.y));
3323                         color.y = color.z;
3324                         color.x = UnpackLow(As<Byte8>(color.x), As<Byte8>(color.x));
3325                         color.y = UnpackHigh(As<Byte8>(color.y), As<Byte8>(color.y));
3326                         color.z = UnpackLow(As<Byte8>(color.z), As<Byte8>(color.z));
3327
3328                         pixel.x = convertUnsigned16(As<UShort4>(color.z));
3329                         pixel.y = convertUnsigned16(As<UShort4>(color.y));
3330                         pixel.z = convertUnsigned16(As<UShort4>(color.x));
3331                         pixel.w = Float4(1.0f);
3332                         break;
3333                 case FORMAT_A8:
3334                         buffer = cBuffer + 1 * x;
3335                         c01 = Insert(c01, *Pointer<Short>(buffer), 0);
3336                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3337                         c01 = Insert(c01, *Pointer<Short>(buffer), 1);
3338                         pixel.w = convertUnsigned16(As<UShort4>(UnpackLow(As<Byte8>(c01), As<Byte8>(c01))));
3339                         pixel.x = Float4(0.0f);
3340                         pixel.y = Float4(0.0f);
3341                         pixel.z = Float4(0.0f);
3342                         break;
3343                 case FORMAT_A8G8R8B8Q:
3344                         UNIMPLEMENTED();
3345                 //      UnpackLow(pixel.z, qword_ptr [cBuffer+8*x+0]);
3346                 //      UnpackHigh(pixel.x, qword_ptr [cBuffer+8*x+0]);
3347                 //      UnpackLow(pixel.y, qword_ptr [cBuffer+8*x+8]);
3348                 //      UnpackHigh(pixel.w, qword_ptr [cBuffer+8*x+8]);
3349                         break;
3350                 case FORMAT_X8G8R8B8Q:
3351                         UNIMPLEMENTED();
3352                 //      UnpackLow(pixel.z, qword_ptr [cBuffer+8*x+0]);
3353                 //      UnpackHigh(pixel.x, qword_ptr [cBuffer+8*x+0]);
3354                 //      UnpackLow(pixel.y, qword_ptr [cBuffer+8*x+8]);
3355                 //      pixel.w = Short4(0xFFFFu);
3356                         break;
3357                 case FORMAT_A16B16G16R16:
3358                         buffer  = cBuffer;
3359                         color.x = *Pointer<Short4>(buffer + 8 * x);
3360                         color.y = *Pointer<Short4>(buffer + 8 * x + 8);
3361                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3362                         color.z = *Pointer<Short4>(buffer + 8 * x);
3363                         color.w = *Pointer<Short4>(buffer + 8 * x + 8);
3364
3365                         transpose4x4(color.x, color.y, color.z, color.w);
3366
3367                         pixel.x = convertUnsigned16(As<UShort4>(color.x));
3368                         pixel.y = convertUnsigned16(As<UShort4>(color.y));
3369                         pixel.z = convertUnsigned16(As<UShort4>(color.z));
3370                         pixel.w = convertUnsigned16(As<UShort4>(color.w));
3371                         break;
3372                 case FORMAT_G16R16:
3373                         buffer = cBuffer;
3374                         color.x = *Pointer<Short4>(buffer  + 4 * x);
3375                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3376                         color.y = *Pointer<Short4>(buffer  + 4 * x);
3377                         color.z = color.x;
3378                         color.x = As<Short4>(UnpackLow(color.x, color.y));
3379                         color.z = As<Short4>(UnpackHigh(color.z, color.y));
3380                         color.y = color.z;
3381                         color.x = As<Short4>(UnpackLow(color.x, color.z));
3382                         color.y = As<Short4>(UnpackHigh(color.y, color.z));
3383
3384                         pixel.x = convertUnsigned16(As<UShort4>(color.x));
3385                         pixel.y = convertUnsigned16(As<UShort4>(color.y));
3386                         pixel.z = Float4(1.0f);
3387                         pixel.w = Float4(1.0f);
3388                         break;
3389                 case FORMAT_R32F:
3390                         buffer = cBuffer;
3391                         // FIXME: movlps
3392                         pixel.x.x = *Pointer<Float>(buffer + 4 * x + 0);
3393                         pixel.x.y = *Pointer<Float>(buffer + 4 * x + 4);
3394                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3395                         // FIXME: movhps
3396                         pixel.x.z = *Pointer<Float>(buffer + 4 * x + 0);
3397                         pixel.x.w = *Pointer<Float>(buffer + 4 * x + 4);
3398                         pixel.y = Float4(1.0f);
3399                         pixel.z = Float4(1.0f);
3400                         pixel.w = Float4(1.0f);
3401                         break;
3402                 case FORMAT_G32R32F:
3403                         buffer = cBuffer;
3404                         pixel.x = *Pointer<Float4>(buffer + 8 * x, 16);
3405                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3406                         pixel.y = *Pointer<Float4>(buffer + 8 * x, 16);
3407                         pixel.z = pixel.x;
3408                         pixel.x = ShuffleLowHigh(pixel.x, pixel.y, 0x88);
3409                         pixel.z = ShuffleLowHigh(pixel.z, pixel.y, 0xDD);
3410                         pixel.y = pixel.z;
3411                         pixel.z = Float4(1.0f);
3412                         pixel.w = Float4(1.0f);
3413                         break;
3414                 case FORMAT_A32B32G32R32F:
3415                         buffer = cBuffer;
3416                         pixel.x = *Pointer<Float4>(buffer + 16 * x, 16);
3417                         pixel.y = *Pointer<Float4>(buffer + 16 * x + 16, 16);
3418                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3419                         pixel.z = *Pointer<Float4>(buffer + 16 * x, 16);
3420                         pixel.w = *Pointer<Float4>(buffer + 16 * x + 16, 16);
3421                         transpose4x4(pixel.x, pixel.y, pixel.z, pixel.w);
3422                         break;
3423                 default:
3424                         ASSERT(false);
3425                 }
3426
3427                 if(postBlendSRGB && state.writeSRGB)
3428                 {
3429                         sRGBtoLinear(pixel.x);
3430                         sRGBtoLinear(pixel.y);
3431                         sRGBtoLinear(pixel.z);
3432                 }
3433
3434                 // Final Color = ObjectColor * SourceBlendFactor + PixelColor * DestinationBlendFactor
3435                 Vector4f sourceFactor;
3436                 Vector4f destFactor;
3437
3438                 blendFactor(r, sourceFactor, oC, pixel, state.sourceBlendFactor);
3439                 blendFactor(r, destFactor, oC, pixel, state.destBlendFactor);
3440
3441                 if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
3442                 {
3443                         oC.x *= sourceFactor.x;
3444                         oC.y *= sourceFactor.y;
3445                         oC.z *= sourceFactor.z;
3446                 }
3447
3448                 if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
3449                 {
3450                         pixel.x *= destFactor.x;
3451                         pixel.y *= destFactor.y;
3452                         pixel.z *= destFactor.z;
3453                 }
3454
3455                 switch(state.blendOperation)
3456                 {
3457                 case BLENDOP_ADD:
3458                         oC.x += pixel.x;
3459                         oC.y += pixel.y;
3460                         oC.z += pixel.z;
3461                         break;
3462                 case BLENDOP_SUB:
3463                         oC.x -= pixel.x;
3464                         oC.y -= pixel.y;
3465                         oC.z -= pixel.z;
3466                         break;
3467                 case BLENDOP_INVSUB:
3468                         oC.x = pixel.x - oC.x;
3469                         oC.y = pixel.y - oC.y;
3470                         oC.z = pixel.z - oC.z;
3471                         break;
3472                 case BLENDOP_MIN:
3473                         oC.x = Min(oC.x, pixel.x);
3474                         oC.y = Min(oC.y, pixel.y);
3475                         oC.z = Min(oC.z, pixel.z);
3476                         break;
3477                 case BLENDOP_MAX:
3478                         oC.x = Max(oC.x, pixel.x);
3479                         oC.y = Max(oC.y, pixel.y);
3480                         oC.z = Max(oC.z, pixel.z);
3481                         break;
3482                 case BLENDOP_SOURCE:
3483                         // No operation
3484                         break;
3485                 case BLENDOP_DEST:
3486                         oC.x = pixel.x;
3487                         oC.y = pixel.y;
3488                         oC.z = pixel.z;
3489                         break;
3490                 case BLENDOP_NULL:
3491                         oC.x = Float4(0.0f);
3492                         oC.y = Float4(0.0f);
3493                         oC.z = Float4(0.0f);
3494                         break;
3495                 default:
3496                         ASSERT(false);
3497                 }
3498
3499                 blendFactorAlpha(r, sourceFactor, oC, pixel, state.sourceBlendFactorAlpha);
3500                 blendFactorAlpha(r, destFactor, oC, pixel, state.destBlendFactorAlpha);
3501
3502                 if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
3503                 {
3504                         oC.w *= sourceFactor.w;
3505                 }
3506
3507                 if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
3508                 {
3509                         pixel.w *= destFactor.w;
3510                 }
3511
3512                 switch(state.blendOperationAlpha)
3513                 {
3514                 case BLENDOP_ADD:
3515                         oC.w += pixel.w;
3516                         break;
3517                 case BLENDOP_SUB:
3518                         oC.w -= pixel.w;
3519                         break;
3520                 case BLENDOP_INVSUB:
3521                         pixel.w -= oC.w;
3522                         oC.w = pixel.w;
3523                         break;
3524                 case BLENDOP_MIN:
3525                         oC.w = Min(oC.w, pixel.w);
3526                         break;
3527                 case BLENDOP_MAX:
3528                         oC.w = Max(oC.w, pixel.w);
3529                         break;
3530                 case BLENDOP_SOURCE:
3531                         // No operation
3532                         break;
3533                 case BLENDOP_DEST:
3534                         oC.w = pixel.w;
3535                         break;
3536                 case BLENDOP_NULL:
3537                         oC.w = Float4(0.0f);
3538                         break;
3539                 default:
3540                         ASSERT(false);
3541                 }
3542         }
3543
3544         void PixelRoutine::writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &x, Vector4f &oC, Int &sMask, Int &zMask, Int &cMask)
3545         {
3546                 if(!state.colorWriteActive(index))
3547                 {
3548                         return;
3549                 }
3550
3551                 Vector4s color;
3552
3553                 switch(state.targetFormat[index])
3554                 {
3555                 case FORMAT_X8R8G8B8:
3556                 case FORMAT_X8B8G8R8:
3557                 case FORMAT_A8R8G8B8:
3558                 case FORMAT_A8B8G8R8:
3559                 case FORMAT_A8:
3560                 case FORMAT_G16R16:
3561                 case FORMAT_A16B16G16R16:
3562                         convertFixed16(color, oC, true);
3563                         writeColor(r, index, cBuffer, x, color, sMask, zMask, cMask);
3564                         return;
3565                 case FORMAT_R32F:
3566                         break;
3567                 case FORMAT_G32R32F:
3568                         oC.z = oC.x;
3569                         oC.x = UnpackLow(oC.x, oC.y);
3570                         oC.z = UnpackHigh(oC.z, oC.y);
3571                         oC.y = oC.z;
3572                         break;
3573                 case FORMAT_A32B32G32R32F:
3574                         transpose4x4(oC.x, oC.y, oC.z, oC.w);
3575                         break;
3576                 default:
3577                         ASSERT(false);
3578                 }
3579
3580                 int rgbaWriteMask = state.colorWriteActive(index);
3581
3582                 Int xMask;   // Combination of all masks
3583
3584                 if(state.depthTestActive)
3585                 {
3586                         xMask = zMask;
3587                 }
3588                 else
3589                 {
3590                         xMask = cMask;
3591                 }
3592
3593                 if(state.stencilActive)
3594                 {
3595                         xMask &= sMask;
3596                 }
3597
3598                 Pointer<Byte> buffer;
3599                 Float4 value;
3600
3601                 switch(state.targetFormat[index])
3602                 {
3603                 case FORMAT_R32F:
3604                         if(rgbaWriteMask & 0x00000001)
3605                         {
3606                                 buffer = cBuffer + 4 * x;
3607
3608                                 // FIXME: movlps
3609                                 value.x = *Pointer<Float>(buffer + 0);
3610                                 value.y = *Pointer<Float>(buffer + 4);
3611
3612                                 buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3613
3614                                 // FIXME: movhps
3615                                 value.z = *Pointer<Float>(buffer + 0);
3616                                 value.w = *Pointer<Float>(buffer + 4);
3617
3618                                 oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X) + xMask * 16, 16));
3619                                 value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X) + xMask * 16, 16));
3620                                 oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(value));
3621
3622                                 // FIXME: movhps
3623                                 *Pointer<Float>(buffer + 0) = oC.x.z;
3624                                 *Pointer<Float>(buffer + 4) = oC.x.w;
3625
3626                                 buffer -= *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3627
3628                                 // FIXME: movlps
3629                                 *Pointer<Float>(buffer + 0) = oC.x.x;
3630                                 *Pointer<Float>(buffer + 4) = oC.x.y;
3631                         }
3632                         break;
3633                 case FORMAT_G32R32F:
3634                         buffer = cBuffer + 8 * x;
3635
3636                         value = *Pointer<Float4>(buffer);
3637
3638                         if((rgbaWriteMask & 0x00000003) != 0x00000003)
3639                         {
3640                                 Float4 masked = value;
3641                                 oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD01X[rgbaWriteMask & 0x3][0])));
3642                                 masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD01X[rgbaWriteMask & 0x3][0])));
3643                                 oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(masked));
3644                         }
3645
3646                         oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskQ01X) + xMask * 16, 16));
3647                         value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskQ01X) + xMask * 16, 16));
3648                         oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(value));
3649                         *Pointer<Float4>(buffer) = oC.x;
3650
3651                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3652
3653                         value = *Pointer<Float4>(buffer);
3654
3655                         if((rgbaWriteMask & 0x00000003) != 0x00000003)
3656                         {
3657                                 Float4 masked;
3658
3659                                 masked = value;
3660                                 oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD01X[rgbaWriteMask & 0x3][0])));
3661                                 masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD01X[rgbaWriteMask & 0x3][0])));
3662                                 oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(masked));
3663                         }
3664
3665                         oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskQ23X) + xMask * 16, 16));
3666                         value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskQ23X) + xMask * 16, 16));
3667                         oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(value));
3668                         *Pointer<Float4>(buffer) = oC.y;
3669                         break;
3670                 case FORMAT_A32B32G32R32F:
3671                         buffer = cBuffer + 16 * x;
3672
3673                         {
3674                                 value = *Pointer<Float4>(buffer, 16);
3675
3676                                 if(rgbaWriteMask != 0x0000000F)
3677                                 {
3678                                         Float4 masked = value;
3679                                         oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
3680                                         masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
3681                                         oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(masked));
3682                                 }
3683
3684                                 oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX0X) + xMask * 16, 16));
3685                                 value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX0X) + xMask * 16, 16));
3686                                 oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(value));
3687                                 *Pointer<Float4>(buffer, 16) = oC.x;
3688                         }
3689
3690                         {
3691                                 value = *Pointer<Float4>(buffer + 16, 16);
3692
3693                                 if(rgbaWriteMask != 0x0000000F)
3694                                 {
3695                                         Float4 masked = value;
3696                                         oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
3697                                         masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
3698                                         oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(masked));
3699                                 }
3700
3701                                 oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX1X) + xMask * 16, 16));
3702                                 value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX1X) + xMask * 16, 16));
3703                                 oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(value));
3704                                 *Pointer<Float4>(buffer + 16, 16) = oC.y;
3705                         }
3706
3707                         buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
3708
3709                         {
3710                                 value = *Pointer<Float4>(buffer, 16);
3711
3712                                 if(rgbaWriteMask != 0x0000000F)
3713                                 {
3714                                         Float4 masked = value;
3715                                         oC.z = As<Float4>(As<Int4>(oC.z) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
3716                                         masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
3717                                         oC.z = As<Float4>(As<Int4>(oC.z) | As<Int4>(masked));
3718                                 }
3719
3720                                 oC.z = As<Float4>(As<Int4>(oC.z) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX2X) + xMask * 16, 16));
3721                                 value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX2X) + xMask * 16, 16));
3722                                 oC.z = As<Float4>(As<Int4>(oC.z) | As<Int4>(value));
3723                                 *Pointer<Float4>(buffer, 16) = oC.z;
3724                         }
3725
3726                         {
3727                                 value = *Pointer<Float4>(buffer + 16, 16);
3728
3729                                 if(rgbaWriteMask != 0x0000000F)
3730                                 {
3731                                         Float4 masked = value;
3732                                         oC.w = As<Float4>(As<Int4>(oC.w) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
3733                                         masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
3734                                         oC.w = As<Float4>(As<Int4>(oC.w) | As<Int4>(masked));
3735                                 }
3736
3737                                 oC.w = As<Float4>(As<Int4>(oC.w) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX3X) + xMask * 16, 16));
3738                                 value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX3X) + xMask * 16, 16));
3739                                 oC.w = As<Float4>(As<Int4>(oC.w) | As<Int4>(value));
3740                                 *Pointer<Float4>(buffer + 16, 16) = oC.w;
3741                         }
3742                         break;
3743                 default:
3744                         ASSERT(false);
3745                 }
3746         }
3747
3748         void PixelRoutine::ps_1_x(Registers &r, Int cMask[4])
3749         {
3750                 int pad = 0;        // Count number of texm3x3pad instructions
3751                 Vector4s dPairing;   // Destination for first pairing instruction
3752
3753                 for(size_t i = 0; i < shader->getLength(); i++)
3754                 {
3755                         const Shader::Instruction *instruction = shader->getInstruction(i);
3756                         Shader::Opcode opcode = instruction->opcode;
3757
3758                 //      #ifndef NDEBUG   // FIXME: Centralize debug output control
3759                 //              shader->printInstruction(i, "debug.txt");
3760                 //      #endif
3761
3762                         if(opcode == Shader::OPCODE_DCL || opcode == Shader::OPCODE_DEF || opcode == Shader::OPCODE_DEFI || opcode == Shader::OPCODE_DEFB)
3763                         {
3764                                 continue;
3765                         }
3766
3767                         const Dst &dst = instruction->dst;
3768                         const Src &src0 = instruction->src[0];
3769                         const Src &src1 = instruction->src[1];
3770                         const Src &src2 = instruction->src[2];
3771
3772                         unsigned short version = shader->getVersion();
3773                         bool pairing = i + 1 < shader->getLength() && shader->getInstruction(i + 1)->coissue;   // First instruction of pair
3774                         bool coissue = instruction->coissue;                                                              // Second instruction of pair
3775
3776                         Vector4s d;
3777                         Vector4s s0;
3778                         Vector4s s1;
3779                         Vector4s s2;
3780
3781                         if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegisterS(r, src0);
3782                         if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterS(r, src1);
3783                         if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterS(r, src2);
3784
3785                         Float4 u = version < 0x0104 ? r.vf[2 + dst.index].x : r.vf[2 + src0.index].x;
3786                         Float4 v = version < 0x0104 ? r.vf[2 + dst.index].y : r.vf[2 + src0.index].y;
3787                         Float4 s = version < 0x0104 ? r.vf[2 + dst.index].z : r.vf[2 + src0.index].z;
3788                         Float4 t = version < 0x0104 ? r.vf[2 + dst.index].w : r.vf[2 + src0.index].w;
3789
3790                         switch(opcode)
3791                         {
3792                         case Shader::OPCODE_PS_1_0:                                                                                                                     break;
3793                         case Shader::OPCODE_PS_1_1:                                                                                                                     break;
3794                         case Shader::OPCODE_PS_1_2:                                                                                                                     break;
3795                         case Shader::OPCODE_PS_1_3:                                                                                                                     break;
3796                         case Shader::OPCODE_PS_1_4:                                                                                                                     break;
3797
3798                         case Shader::OPCODE_DEF:                                                                                                                        break;
3799
3800                         case Shader::OPCODE_NOP:                                                                                                                        break;
3801                         case Shader::OPCODE_MOV:                        MOV(d, s0);                                                                             break;
3802                         case Shader::OPCODE_ADD:                        ADD(d, s0, s1);                                                                 break;
3803                         case Shader::OPCODE_SUB:                        SUB(d, s0, s1);                                                                 break;
3804                         case Shader::OPCODE_MAD:                        MAD(d, s0, s1, s2);                                                             break;
3805                         case Shader::OPCODE_MUL:                        MUL(d, s0, s1);                                                                 break;
3806                         case Shader::OPCODE_DP3:                        DP3(d, s0, s1);                                                                 break;
3807                         case Shader::OPCODE_DP4:                        DP4(d, s0, s1);                                                                 break;
3808                         case Shader::OPCODE_LRP:                        LRP(d, s0, s1, s2);                                                             break;
3809                         case Shader::OPCODE_TEXCOORD:
3810                                 if(version < 0x0104)
3811                                 {
3812                                         TEXCOORD(d, u, v, s, dst.index);
3813                                 }
3814                                 else
3815                                 {
3816                                         if((src0.swizzle & 0x30) == 0x20)   // .xyz
3817                                         {
3818                                                 TEXCRD(d, u, v, s, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
3819                                         }
3820                                         else   // .xyw
3821                                         {
3822                                                 TEXCRD(d, u, v, t, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
3823                                         }
3824                                 }
3825                                 break;
3826                         case Shader::OPCODE_TEXKILL:
3827                                 if(version < 0x0104)
3828                                 {
3829                                         TEXKILL(cMask, u, v, s);
3830                                 }
3831                                 else if(version == 0x0104)
3832                                 {
3833                                         if(dst.type == Shader::PARAMETER_TEXTURE)
3834                                         {
3835                                                 TEXKILL(cMask, u, v, s);
3836                                         }
3837                                         else
3838                                         {
3839                                                 TEXKILL(cMask, r.rs[dst.index]);
3840                                         }
3841                                 }
3842                                 else ASSERT(false);
3843                                 break;
3844                         case Shader::OPCODE_TEX:
3845                                 if(version < 0x0104)
3846                                 {
3847                                         TEX(r, d, u, v, s, dst.index, false);
3848                                 }
3849                                 else if(version == 0x0104)
3850                                 {
3851                                         if(src0.type == Shader::PARAMETER_TEXTURE)
3852                                         {
3853                                                 if((src0.swizzle & 0x30) == 0x20)   // .xyz
3854                                                 {
3855                                                         TEX(r, d, u, v, s, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
3856                                                 }
3857                                                 else   // .xyw
3858                                                 {
3859                                                         TEX(r, d, u, v, t, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
3860                                                 }
3861                                         }
3862                                         else
3863                                         {
3864                                                 TEXLD(r, d, s0, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
3865                                         }
3866                                 }
3867                                 else ASSERT(false);
3868                                 break;
3869                         case Shader::OPCODE_TEXBEM:                     TEXBEM(r, d, s0, u, v, s, dst.index);   break;
3870                         case Shader::OPCODE_TEXBEML:            TEXBEML(r, d, s0, u, v, s, dst.index);  break;
3871                         case Shader::OPCODE_TEXREG2AR:          TEXREG2AR(r, d, s0, dst.index);                                 break;
3872                         case Shader::OPCODE_TEXREG2GB:          TEXREG2GB(r, d, s0, dst.index);                                 break;
3873                         case Shader::OPCODE_TEXM3X2PAD:         TEXM3X2PAD(r, u, v, s, s0, 0, src0.modifier == Shader::MODIFIER_SIGN);  break;
3874                         case Shader::OPCODE_TEXM3X2TEX:         TEXM3X2TEX(r, d, u, v, s, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN);       break;
3875                         case Shader::OPCODE_TEXM3X3PAD:         TEXM3X3PAD(r, u, v, s, s0, pad++ % 2, src0.modifier == Shader::MODIFIER_SIGN);  break;
3876                         case Shader::OPCODE_TEXM3X3TEX:         TEXM3X3TEX(r, d, u, v, s, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN);       break;
3877                         case Shader::OPCODE_TEXM3X3SPEC:        TEXM3X3SPEC(r, d, u, v, s, dst.index, s0, s1);          break;
3878                         case Shader::OPCODE_TEXM3X3VSPEC:       TEXM3X3VSPEC(r, d, u, v, s, dst.index, s0);             break;
3879                         case Shader::OPCODE_CND:                        CND(d, s0, s1, s2);                                                             break;
3880                         case Shader::OPCODE_TEXREG2RGB:         TEXREG2RGB(r, d, s0, dst.index);                                break;
3881                         case Shader::OPCODE_TEXDP3TEX:          TEXDP3TEX(r, d, u, v, s, dst.index, s0);        break;
3882                         case Shader::OPCODE_TEXM3X2DEPTH:       TEXM3X2DEPTH(r, d, u, v, s, s0, src0.modifier == Shader::MODIFIER_SIGN);        break;
3883                         case Shader::OPCODE_TEXDP3:                     TEXDP3(r, d, u, v, s, s0);                              break;
3884                         case Shader::OPCODE_TEXM3X3:            TEXM3X3(r, d, u, v, s, s0, src0.modifier == Shader::MODIFIER_SIGN);     break;
3885                         case Shader::OPCODE_TEXDEPTH:           TEXDEPTH(r);                                                                    break;
3886                         case Shader::OPCODE_CMP0:                       CMP(d, s0, s1, s2);                                                             break;
3887                         case Shader::OPCODE_BEM:                        BEM(r, d, s0, s1, dst.index);                                   break;
3888                         case Shader::OPCODE_PHASE:                                                                                                                      break;
3889                         case Shader::OPCODE_END:                                                                                                                        break;
3890                         default:
3891                                 ASSERT(false);
3892                         }
3893
3894                         if(dst.type != Shader::PARAMETER_VOID && opcode != Shader::OPCODE_TEXKILL)
3895                         {
3896                                 if(dst.shift > 0)
3897                                 {
3898                                         if(dst.mask & 0x1) {d.x = AddSat(d.x, d.x); if(dst.shift > 1) d.x = AddSat(d.x, d.x); if(dst.shift > 2) d.x = AddSat(d.x, d.x);}
3899                                         if(dst.mask & 0x2) {d.y = AddSat(d.y, d.y); if(dst.shift > 1) d.y = AddSat(d.y, d.y); if(dst.shift > 2) d.y = AddSat(d.y, d.y);}
3900                                         if(dst.mask & 0x4) {d.z = AddSat(d.z, d.z); if(dst.shift > 1) d.z = AddSat(d.z, d.z); if(dst.shift > 2) d.z = AddSat(d.z, d.z);}
3901                                         if(dst.mask & 0x8) {d.w = AddSat(d.w, d.w); if(dst.shift > 1) d.w = AddSat(d.w, d.w); if(dst.shift > 2) d.w = AddSat(d.w, d.w);}
3902                                 }
3903                                 else if(dst.shift < 0)
3904                                 {
3905                                         if(dst.mask & 0x1) d.x = d.x >> -dst.shift;
3906                                         if(dst.mask & 0x2) d.y = d.y >> -dst.shift;
3907                                         if(dst.mask & 0x4) d.z = d.z >> -dst.shift;
3908                                         if(dst.mask & 0x8) d.w = d.w >> -dst.shift;
3909                                 }
3910
3911                                 if(dst.saturate)
3912                                 {
3913                                         if(dst.mask & 0x1) {d.x = Min(d.x, Short4(0x1000)); d.x = Max(d.x, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
3914                                         if(dst.mask & 0x2) {d.y = Min(d.y, Short4(0x1000)); d.y = Max(d.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
3915                                         if(dst.mask & 0x4) {d.z = Min(d.z, Short4(0x1000)); d.z = Max(d.z, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
3916                                         if(dst.mask & 0x8) {d.w = Min(d.w, Short4(0x1000)); d.w = Max(d.w, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
3917                                 }
3918
3919                                 if(pairing)
3920                                 {
3921                                         if(dst.mask & 0x1) dPairing.x = d.x;
3922                                         if(dst.mask & 0x2) dPairing.y = d.y;
3923                                         if(dst.mask & 0x4) dPairing.z = d.z;
3924                                         if(dst.mask & 0x8) dPairing.w = d.w;
3925                                 }
3926
3927                                 if(coissue)
3928                                 {
3929                                         const Dst &dst = shader->getInstruction(i - 1)->dst;
3930
3931                                         writeDestination(r, dPairing, dst);
3932                                 }
3933
3934                                 if(!pairing)
3935                                 {
3936                                         writeDestination(r, d, dst);
3937                                 }
3938                         }
3939                 }
3940         }
3941
3942         void PixelRoutine::ps_2_x(Registers &r, Int cMask[4])
3943         {
3944                 r.enableIndex = 0;
3945                 r.stackIndex = 0;
3946
3947                 if(shader->containsLeaveInstruction())
3948                 {
3949                         r.enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
3950                 }
3951
3952                 bool out[4][4] = {false};
3953
3954                 // Create all call site return blocks up front
3955                 for(size_t i = 0; i < shader->getLength(); i++)
3956                 {
3957                         const Shader::Instruction *instruction = shader->getInstruction(i);
3958                         Shader::Opcode opcode = instruction->opcode;
3959
3960                         if(opcode == Shader::OPCODE_CALL || opcode == Shader::OPCODE_CALLNZ)
3961                         {
3962                                 const Dst &dst = instruction->dst;
3963
3964                                 ASSERT(callRetBlock[dst.label].size() == dst.callSite);
3965                                 callRetBlock[dst.label].push_back(Nucleus::createBasicBlock());
3966                         }
3967                 }
3968
3969                 for(size_t i = 0; i < shader->getLength(); i++)
3970                 {
3971                         const Shader::Instruction *instruction = shader->getInstruction(i);
3972                         Shader::Opcode opcode = instruction->opcode;
3973
3974                         if(opcode == Shader::OPCODE_DCL || opcode == Shader::OPCODE_DEF || opcode == Shader::OPCODE_DEFI || opcode == Shader::OPCODE_DEFB)
3975                         {
3976                                 continue;
3977                         }
3978
3979                         const Dst &dst = instruction->dst;
3980                         const Src &src0 = instruction->src[0];
3981                         const Src &src1 = instruction->src[1];
3982                         const Src &src2 = instruction->src[2];
3983                         const Src &src3 = instruction->src[3];
3984
3985                         bool predicate = instruction->predicate;
3986                         Control control = instruction->control;
3987                         bool pp = dst.partialPrecision;
3988                         bool project = instruction->project;
3989                         bool bias = instruction->bias;
3990
3991                         Vector4f d;
3992                         Vector4f s0;
3993                         Vector4f s1;
3994                         Vector4f s2;
3995                         Vector4f s3;
3996
3997                         if(opcode == Shader::OPCODE_TEXKILL)   // Takes destination as input
3998                         {
3999                                 if(dst.type == Shader::PARAMETER_TEXTURE)
4000                                 {
4001                                         d.x = r.vf[2 + dst.index].x;
4002                                         d.y = r.vf[2 + dst.index].y;
4003                                         d.z = r.vf[2 + dst.index].z;
4004                                         d.w = r.vf[2 + dst.index].w;
4005                                 }
4006                                 else
4007                                 {
4008                                         d = r.rf[dst.index];
4009                                 }
4010                         }
4011
4012                         if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegisterF(r, src0);
4013                         if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterF(r, src1);
4014                         if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterF(r, src2);
4015                         if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegisterF(r, src3);
4016
4017                         switch(opcode)
4018                         {
4019                         case Shader::OPCODE_PS_2_0:                                                                                                             break;
4020                         case Shader::OPCODE_PS_2_x:                                                                                                             break;
4021                         case Shader::OPCODE_PS_3_0:                                                                                                             break;
4022                         case Shader::OPCODE_DEF:                                                                                                                break;
4023                         case Shader::OPCODE_DCL:                                                                                                                break;
4024                         case Shader::OPCODE_NOP:                                                                                                                break;
4025                         case Shader::OPCODE_MOV:                mov(d, s0);                                                                             break;
4026                         case Shader::OPCODE_F2B:                f2b(d, s0);                                                                             break;
4027                         case Shader::OPCODE_B2F:                b2f(d, s0);                                                                             break;
4028                         case Shader::OPCODE_ADD:                add(d, s0, s1);                                                                 break;
4029                         case Shader::OPCODE_SUB:                sub(d, s0, s1);                                                                 break;
4030                         case Shader::OPCODE_MUL:                mul(d, s0, s1);                                                                 break;
4031                         case Shader::OPCODE_MAD:                mad(d, s0, s1, s2);                                                             break;
4032                         case Shader::OPCODE_DP1:                dp1(d, s0, s1);                                                                 break;
4033                         case Shader::OPCODE_DP2:                dp2(d, s0, s1);                                                                 break;
4034                         case Shader::OPCODE_DP2ADD:             dp2add(d, s0, s1, s2);                                                  break;
4035                         case Shader::OPCODE_DP3:                dp3(d, s0, s1);                                                                 break;
4036                         case Shader::OPCODE_DP4:                dp4(d, s0, s1);                                                                 break;
4037                         case Shader::OPCODE_CMP0:               cmp0(d, s0, s1, s2);                                                    break;
4038                         case Shader::OPCODE_ICMP:               icmp(d, s0, s1, control);                                               break;
4039                         case Shader::OPCODE_SELECT:             select(d, s0, s1, s2);                                                  break;
4040                         case Shader::OPCODE_EXTRACT:    extract(d.x, s0, s1.x);                                                 break;
4041                         case Shader::OPCODE_INSERT:             insert(d, s0, s1.x, s2.x);                                              break;
4042                         case Shader::OPCODE_FRC:                frc(d, s0);                                                                             break;
4043                         case Shader::OPCODE_TRUNC:      trunc(d, s0);                                   break;
4044                         case Shader::OPCODE_FLOOR:      floor(d, s0);                                   break;
4045                         case Shader::OPCODE_CEIL:       ceil(d, s0);                                    break;
4046                         case Shader::OPCODE_EXP2X:              exp2x(d, s0, pp);                                                               break;
4047                         case Shader::OPCODE_EXP2:               exp2(d, s0, pp);                                                                break;
4048                         case Shader::OPCODE_LOG2X:              log2x(d, s0, pp);                                                               break;
4049                         case Shader::OPCODE_LOG2:               log2(d, s0, pp);                                                                break;
4050                         case Shader::OPCODE_EXP:                exp(d, s0, pp);                                                                 break;
4051                         case Shader::OPCODE_LOG:                log(d, s0, pp);                                                                 break;
4052                         case Shader::OPCODE_RCPX:               rcpx(d, s0, pp);                                                                break;
4053                         case Shader::OPCODE_DIV:                div(d, s0, s1);                                                                 break;
4054                         case Shader::OPCODE_MOD:                mod(d, s0, s1);                                                                 break;
4055                         case Shader::OPCODE_RSQX:               rsqx(d, s0, pp);                                                                break;
4056                         case Shader::OPCODE_SQRT:               sqrt(d, s0, pp);                                                                break;
4057                         case Shader::OPCODE_RSQ:                rsq(d, s0, pp);                                                                 break;
4058                         case Shader::OPCODE_LEN2:               len2(d.x, s0, pp);                                                              break;
4059                         case Shader::OPCODE_LEN3:               len3(d.x, s0, pp);                                                              break;
4060                         case Shader::OPCODE_LEN4:               len4(d.x, s0, pp);                                                              break;
4061                         case Shader::OPCODE_DIST1:              dist1(d.x, s0, s1, pp);                                                 break;
4062                         case Shader::OPCODE_DIST2:              dist2(d.x, s0, s1, pp);                                                 break;
4063                         case Shader::OPCODE_DIST3:              dist3(d.x, s0, s1, pp);                                                 break;
4064                         case Shader::OPCODE_DIST4:              dist4(d.x, s0, s1, pp);                                                 break;
4065                         case Shader::OPCODE_MIN:                min(d, s0, s1);                                                                 break;
4066                         case Shader::OPCODE_MAX:                max(d, s0, s1);                                                                 break;
4067                         case Shader::OPCODE_LRP:                lrp(d, s0, s1, s2);                                                             break;
4068                         case Shader::OPCODE_STEP:               step(d, s0, s1);                                                                break;
4069                         case Shader::OPCODE_SMOOTH:             smooth(d, s0, s1, s2);                                                  break;
4070                         case Shader::OPCODE_POWX:               powx(d, s0, s1, pp);                                                    break;
4071                         case Shader::OPCODE_POW:                pow(d, s0, s1, pp);                                                             break;
4072                         case Shader::OPCODE_SGN:                sgn(d, s0);                                                                             break;
4073                         case Shader::OPCODE_CRS:                crs(d, s0, s1);                                                                 break;
4074                         case Shader::OPCODE_FORWARD1:   forward1(d, s0, s1, s2);                                                break;
4075                         case Shader::OPCODE_FORWARD2:   forward2(d, s0, s1, s2);                                                break;
4076                         case Shader::OPCODE_FORWARD3:   forward3(d, s0, s1, s2);                                                break;
4077                         case Shader::OPCODE_FORWARD4:   forward4(d, s0, s1, s2);                                                break;
4078                         case Shader::OPCODE_REFLECT1:   reflect1(d, s0, s1);                                                    break;
4079                         case Shader::OPCODE_REFLECT2:   reflect2(d, s0, s1);                                                    break;
4080                         case Shader::OPCODE_REFLECT3:   reflect3(d, s0, s1);                                                    break;
4081                         case Shader::OPCODE_REFLECT4:   reflect4(d, s0, s1);                                                    break;
4082                         case Shader::OPCODE_REFRACT1:   refract1(d, s0, s1, s2.x);                                              break;
4083                         case Shader::OPCODE_REFRACT2:   refract2(d, s0, s1, s2.x);                                              break;
4084                         case Shader::OPCODE_REFRACT3:   refract3(d, s0, s1, s2.x);                                              break;
4085                         case Shader::OPCODE_REFRACT4:   refract4(d, s0, s1, s2.x);                                              break;
4086                         case Shader::OPCODE_NRM2:               nrm2(d, s0, pp);                                                                break;
4087                         case Shader::OPCODE_NRM3:               nrm3(d, s0, pp);                                                                break;
4088                         case Shader::OPCODE_NRM4:               nrm4(d, s0, pp);                                                                break;
4089                         case Shader::OPCODE_ABS:                abs(d, s0);                                                                             break;
4090                         case Shader::OPCODE_SINCOS:             sincos(d, s0, pp);                                                              break;
4091                         case Shader::OPCODE_COS:                cos(d, s0, pp);                                                                 break;
4092                         case Shader::OPCODE_SIN:                sin(d, s0, pp);                                                                 break;
4093                         case Shader::OPCODE_TAN:                tan(d, s0, pp);                                                                 break;
4094                         case Shader::OPCODE_ACOS:               acos(d, s0, pp);                                                                break;
4095                         case Shader::OPCODE_ASIN:               asin(d, s0, pp);                                                                break;
4096                         case Shader::OPCODE_ATAN:               atan(d, s0, pp);                                                                break;
4097                         case Shader::OPCODE_ATAN2:              atan2(d, s0, s1, pp);                                                   break;
4098                         case Shader::OPCODE_M4X4:               M4X4(r, d, s0, src1);                                                   break;
4099                         case Shader::OPCODE_M4X3:               M4X3(r, d, s0, src1);                                                   break;
4100                         case Shader::OPCODE_M3X4:               M3X4(r, d, s0, src1);                                                   break;
4101                         case Shader::OPCODE_M3X3:               M3X3(r, d, s0, src1);                                                   break;
4102                         case Shader::OPCODE_M3X2:               M3X2(r, d, s0, src1);                                                   break;
4103                         case Shader::OPCODE_TEX:                TEXLD(r, d, s0, src1, project, bias);                   break;
4104                         case Shader::OPCODE_TEXLDD:             TEXLDD(r, d, s0, src1, s2, s3, project, bias);  break;
4105                         case Shader::OPCODE_TEXLDL:             TEXLDL(r, d, s0, src1, project, bias);                  break;
4106                         case Shader::OPCODE_TEXKILL:    TEXKILL(cMask, d, dst.mask);                                    break;
4107                         case Shader::OPCODE_DISCARD:    DISCARD(r, cMask, instruction);                                 break;
4108                         case Shader::OPCODE_DFDX:               DFDX(d, s0);                                                                    break;
4109                         case Shader::OPCODE_DFDY:               DFDY(d, s0);                                                                    break;
4110                         case Shader::OPCODE_FWIDTH:             FWIDTH(d, s0);                                                                  break;
4111                         case Shader::OPCODE_BREAK:              BREAK(r);                                                                               break;
4112                         case Shader::OPCODE_BREAKC:             BREAKC(r, s0, s1, control);                                             break;
4113                         case Shader::OPCODE_BREAKP:             BREAKP(r, src0);                                                                break;
4114                         case Shader::OPCODE_CONTINUE:   CONTINUE(r);                                                                    break;
4115                         case Shader::OPCODE_TEST:               TEST();                                                                                 break;
4116                         case Shader::OPCODE_CALL:               CALL(r, dst.label, dst.callSite);               break;
4117                         case Shader::OPCODE_CALLNZ:             CALLNZ(r, dst.label, dst.callSite, src0);       break;
4118                         case Shader::OPCODE_ELSE:               ELSE(r);                                                                                break;
4119                         case Shader::OPCODE_ENDIF:              ENDIF(r);                                                                               break;
4120                         case Shader::OPCODE_ENDLOOP:    ENDLOOP(r);                                                                             break;
4121                         case Shader::OPCODE_ENDREP:             ENDREP(r);                                                                              break;
4122                         case Shader::OPCODE_ENDWHILE:   ENDWHILE(r);                                                            break;
4123                         case Shader::OPCODE_IF:                 IF(r, src0);                                                                    break;
4124                         case Shader::OPCODE_IFC:                IFC(r, s0, s1, control);                                                break;
4125                         case Shader::OPCODE_LABEL:              LABEL(dst.index);                                                               break;
4126                         case Shader::OPCODE_LOOP:               LOOP(r, src1);                                                                  break;
4127                         case Shader::OPCODE_REP:                REP(r, src0);                                                                   break;
4128                         case Shader::OPCODE_WHILE:              WHILE(r, src0);                                                                 break;
4129                         case Shader::OPCODE_RET:                RET(r);                                                                                 break;
4130                         case Shader::OPCODE_LEAVE:              LEAVE(r);                                                                               break;
4131                         case Shader::OPCODE_CMP:                cmp(d, s0, s1, control);                                                break;
4132                         case Shader::OPCODE_ALL:                all(d.x, s0);                                                                   break;
4133                         case Shader::OPCODE_ANY:                any(d.x, s0);                                                                   break;
4134                         case Shader::OPCODE_NOT:                not(d, s0);                                                                             break;
4135                         case Shader::OPCODE_OR:                 or(d.x, s0.x, s1.x);                                                    break;
4136                         case Shader::OPCODE_XOR:                xor(d.x, s0.x, s1.x);                                                   break;
4137                         case Shader::OPCODE_AND:                and(d.x, s0.x, s1.x);                                                   break;
4138                         case Shader::OPCODE_END:                                                                                                                break;
4139                         default:
4140                                 ASSERT(false);
4141                         }
4142
4143                         if(dst.type != Shader::PARAMETER_VOID && dst.type != Shader::PARAMETER_LABEL && opcode != Shader::OPCODE_TEXKILL && opcode != Shader::OPCODE_NOP)
4144                         {
4145                                 if(dst.integer)
4146                                 {
4147                                         switch(opcode)
4148                                         {
4149                                         case Shader::OPCODE_DIV:
4150                                                 if(dst.x) d.x = Trunc(d.x);
4151                                                 if(dst.y) d.y = Trunc(d.y);
4152                                                 if(dst.z) d.z = Trunc(d.z);
4153                                                 if(dst.w) d.w = Trunc(d.w);
4154                                                 break;
4155                                         default:
4156                                                 break;   // No truncation to integer required when arguments are integer
4157                                         }
4158                                 }
4159
4160                                 if(dst.saturate)
4161                                 {
4162                                         if(dst.x) d.x = Max(d.x, Float4(0.0f));
4163                                         if(dst.y) d.y = Max(d.y, Float4(0.0f));
4164                                         if(dst.z) d.z = Max(d.z, Float4(0.0f));
4165                                         if(dst.w) d.w = Max(d.w, Float4(0.0f));
4166
4167                                         if(dst.x) d.x = Min(d.x, Float4(1.0f));
4168                                         if(dst.y) d.y = Min(d.y, Float4(1.0f));
4169                                         if(dst.z) d.z = Min(d.z, Float4(1.0f));
4170                                         if(dst.w) d.w = Min(d.w, Float4(1.0f));
4171                                 }
4172
4173                                 if(instruction->isPredicated())
4174                                 {
4175                                         Vector4f pDst;   // FIXME: Rename
4176
4177                                         switch(dst.type)
4178                                         {
4179                                         case Shader::PARAMETER_TEMP:
4180                                                 if(dst.rel.type == Shader::PARAMETER_VOID)
4181                                                 {
4182                                                         if(dst.x) pDst.x = r.rf[dst.index].x;
4183                                                         if(dst.y) pDst.y = r.rf[dst.index].y;
4184                                                         if(dst.z) pDst.z = r.rf[dst.index].z;
4185                                                         if(dst.w) pDst.w = r.rf[dst.index].w;
4186                                                 }
4187                                                 else
4188                                                 {
4189                                                         Int a = relativeAddress(r, dst);
4190
4191                                                         if(dst.x) pDst.x = r.rf[dst.index + a].x;
4192                                                         if(dst.y) pDst.y = r.rf[dst.index + a].y;
4193                                                         if(dst.z) pDst.z = r.rf[dst.index + a].z;
4194                                                         if(dst.w) pDst.w = r.rf[dst.index + a].w;
4195                                                 }
4196                                                 break;
4197                                         case Shader::PARAMETER_COLOROUT:
4198                                                 ASSERT(dst.rel.type == Shader::PARAMETER_VOID);
4199                                                 if(dst.x) pDst.x = r.oC[dst.index].x;
4200                                                 if(dst.y) pDst.y = r.oC[dst.index].y;
4201                                                 if(dst.z) pDst.z = r.oC[dst.index].z;
4202                                                 if(dst.w) pDst.w = r.oC[dst.index].w;
4203                                                 break;
4204                                         case Shader::PARAMETER_PREDICATE:
4205                                                 if(dst.x) pDst.x = r.p0.x;
4206                                                 if(dst.y) pDst.y = r.p0.y;
4207                                                 if(dst.z) pDst.z = r.p0.z;
4208                                                 if(dst.w) pDst.w = r.p0.w;
4209                                                 break;
4210                                         case Shader::PARAMETER_DEPTHOUT:
4211                                                 pDst.x = r.oDepth;
4212                                                 break;
4213                                         default:
4214                                                 ASSERT(false);
4215                                         }
4216
4217                                         Int4 enable = enableMask(r, instruction);
4218
4219                                         Int4 xEnable = enable;
4220                                         Int4 yEnable = enable;
4221                                         Int4 zEnable = enable;
4222                                         Int4 wEnable = enable;
4223
4224                                         if(predicate)
4225                                         {
4226                                                 unsigned char pSwizzle = instruction->predicateSwizzle;
4227
4228                                                 Float4 xPredicate = r.p0[(pSwizzle >> 0) & 0x03];
4229                                                 Float4 yPredicate = r.p0[(pSwizzle >> 2) & 0x03];
4230                                                 Float4 zPredicate = r.p0[(pSwizzle >> 4) & 0x03];
4231                                                 Float4 wPredicate = r.p0[(pSwizzle >> 6) & 0x03];
4232
4233                                                 if(!instruction->predicateNot)
4234                                                 {
4235                                                         if(dst.x) xEnable = xEnable & As<Int4>(xPredicate);
4236                                                         if(dst.y) yEnable = yEnable & As<Int4>(yPredicate);
4237                                                         if(dst.z) zEnable = zEnable & As<Int4>(zPredicate);
4238                                                         if(dst.w) wEnable = wEnable & As<Int4>(wPredicate);
4239                                                 }
4240                                                 else
4241                                                 {
4242                                                         if(dst.x) xEnable = xEnable & ~As<Int4>(xPredicate);
4243                                                         if(dst.y) yEnable = yEnable & ~As<Int4>(yPredicate);
4244                                                         if(dst.z) zEnable = zEnable & ~As<Int4>(zPredicate);
4245                                                         if(dst.w) wEnable = wEnable & ~As<Int4>(wPredicate);
4246                                                 }
4247                                         }
4248
4249                                         if(dst.x) d.x = As<Float4>(As<Int4>(d.x) & xEnable);
4250                                         if(dst.y) d.y = As<Float4>(As<Int4>(d.y) & yEnable);
4251                                         if(dst.z) d.z = As<Float4>(As<Int4>(d.z) & zEnable);
4252                                         if(dst.w) d.w = As<Float4>(As<Int4>(d.w) & wEnable);
4253
4254                                         if(dst.x) d.x = As<Float4>(As<Int4>(d.x) | (As<Int4>(pDst.x) & ~xEnable));
4255                                         if(dst.y) d.y = As<Float4>(As<Int4>(d.y) | (As<Int4>(pDst.y) & ~yEnable));
4256                                         if(dst.z) d.z = As<Float4>(As<Int4>(d.z) | (As<Int4>(pDst.z) & ~zEnable));
4257                                         if(dst.w) d.w = As<Float4>(As<Int4>(d.w) | (As<Int4>(pDst.w) & ~wEnable));
4258                                 }
4259
4260                                 switch(dst.type)
4261                                 {
4262                                 case Shader::PARAMETER_TEMP:
4263                                         if(dst.rel.type == Shader::PARAMETER_VOID)
4264                                         {
4265                                                 if(dst.x) r.rf[dst.index].x = d.x;
4266                                                 if(dst.y) r.rf[dst.index].y = d.y;
4267                                                 if(dst.z) r.rf[dst.index].z = d.z;
4268                                                 if(dst.w) r.rf[dst.index].w = d.w;
4269                                         }
4270                                         else
4271                                         {
4272                                                 Int a = relativeAddress(r, dst);
4273
4274                                                 if(dst.x) r.rf[dst.index + a].x = d.x;
4275                                                 if(dst.y) r.rf[dst.index + a].y = d.y;
4276                                                 if(dst.z) r.rf[dst.index + a].z = d.z;
4277                                                 if(dst.w) r.rf[dst.index + a].w = d.w;
4278                                         }
4279                                         break;
4280                                 case Shader::PARAMETER_COLOROUT:
4281                                         ASSERT(dst.rel.type == Shader::PARAMETER_VOID);
4282                                         if(dst.x) {r.oC[dst.index].x = d.x; out[dst.index][0] = true;}
4283                                         if(dst.y) {r.oC[dst.index].y = d.y; out[dst.index][1] = true;}
4284                                         if(dst.z) {r.oC[dst.index].z = d.z; out[dst.index][2] = true;}
4285                                         if(dst.w) {r.oC[dst.index].w = d.w; out[dst.index][3] = true;}
4286                                         break;
4287                                 case Shader::PARAMETER_PREDICATE:
4288                                         if(dst.x) r.p0.x = d.x;
4289                                         if(dst.y) r.p0.y = d.y;
4290                                         if(dst.z) r.p0.z = d.z;
4291                                         if(dst.w) r.p0.w = d.w;
4292                                         break;
4293                                 case Shader::PARAMETER_DEPTHOUT:
4294                                         r.oDepth = d.x;
4295                                         break;
4296                                 default:
4297                                         ASSERT(false);
4298                                 }
4299                         }
4300                 }
4301
4302                 if(currentLabel != -1)
4303                 {
4304                         Nucleus::setInsertBlock(returnBlock);
4305                 }
4306
4307                 for(int i = 0; i < 4; i++)
4308                 {
4309                         if(state.targetFormat[i] != FORMAT_NULL)
4310                         {
4311                                 if(!out[i][0]) r.oC[i].x = Float4(0.0f);
4312                                 if(!out[i][1]) r.oC[i].y = Float4(0.0f);
4313                                 if(!out[i][2]) r.oC[i].z = Float4(0.0f);
4314                                 if(!out[i][3]) r.oC[i].w = Float4(0.0f);
4315                         }
4316                 }
4317         }
4318
4319         Short4 PixelRoutine::convertFixed12(RValue<Float4> cf)
4320         {
4321                 return RoundShort4(cf * Float4(0x1000));
4322         }
4323
4324         void PixelRoutine::convertFixed12(Vector4s &cs, Vector4f &cf)
4325         {
4326                 cs.x = convertFixed12(cf.x);
4327                 cs.y = convertFixed12(cf.y);
4328                 cs.z = convertFixed12(cf.z);
4329                 cs.w = convertFixed12(cf.w);
4330         }
4331
4332         UShort4 PixelRoutine::convertFixed16(Float4 &cf, bool saturate)
4333         {
4334                 return UShort4(cf * Float4(0xFFFF), saturate);
4335         }
4336
4337         void PixelRoutine::convertFixed16(Vector4s &cs, Vector4f &cf, bool saturate)
4338         {
4339                 cs.x = convertFixed16(cf.x, saturate);
4340                 cs.y = convertFixed16(cf.y, saturate);
4341                 cs.z = convertFixed16(cf.z, saturate);
4342                 cs.w = convertFixed16(cf.w, saturate);
4343         }
4344
4345         Float4 PixelRoutine::convertSigned12(Short4 &cs)
4346         {
4347                 return Float4(cs) * Float4(1.0f / 0x0FFE);
4348         }
4349
4350         void PixelRoutine::convertSigned12(Vector4f &cf, Vector4s &cs)
4351         {
4352                 cf.x = convertSigned12(cs.x);
4353                 cf.y = convertSigned12(cs.y);
4354                 cf.z = convertSigned12(cs.z);
4355                 cf.w = convertSigned12(cs.w);
4356         }
4357
4358         Float4 PixelRoutine::convertUnsigned16(UShort4 cs)
4359         {
4360                 return Float4(cs) * Float4(1.0f / 0xFFFF);
4361         }
4362
4363         void PixelRoutine::sRGBtoLinear16_16(Registers &r, Vector4s &c)
4364         {
4365                 c.x = As<UShort4>(c.x) >> 4;
4366                 c.y = As<UShort4>(c.y) >> 4;
4367                 c.z = As<UShort4>(c.z) >> 4;
4368
4369                 sRGBtoLinear12_16(r, c);
4370         }
4371
4372         void PixelRoutine::sRGBtoLinear12_16(Registers &r, Vector4s &c)
4373         {
4374                 Pointer<Byte> LUT = r.constants + OFFSET(Constants,sRGBtoLin12_16);
4375
4376                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 0))), 0);
4377                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 1))), 1);
4378                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 2))), 2);
4379                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 3))), 3);
4380
4381                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 0))), 0);
4382                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 1))), 1);
4383                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 2))), 2);
4384                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 3))), 3);
4385
4386                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 0))), 0);
4387                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 1))), 1);
4388                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 2))), 2);
4389                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 3))), 3);
4390         }
4391
4392         void PixelRoutine::linearToSRGB16_16(Registers &r, Vector4s &c)
4393         {
4394                 c.x = As<UShort4>(c.x) >> 4;
4395                 c.y = As<UShort4>(c.y) >> 4;
4396                 c.z = As<UShort4>(c.z) >> 4;
4397
4398                 linearToSRGB12_16(r, c);
4399         }
4400
4401         void PixelRoutine::linearToSRGB12_16(Registers &r, Vector4s &c)
4402         {
4403                 Pointer<Byte> LUT = r.constants + OFFSET(Constants,linToSRGB12_16);
4404
4405                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 0))), 0);
4406                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 1))), 1);
4407                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 2))), 2);
4408                 c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 3))), 3);
4409
4410                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 0))), 0);
4411                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 1))), 1);
4412                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 2))), 2);
4413                 c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 3))), 3);
4414
4415                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 0))), 0);
4416                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 1))), 1);
4417                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 2))), 2);
4418                 c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 3))), 3);
4419         }
4420
4421         Float4 PixelRoutine::linearToSRGB(const Float4 &x)   // Approximates x^(1.0/2.2)
4422         {
4423                 Float4 sqrtx = Rcp_pp(RcpSqrt_pp(x));
4424                 Float4 sRGB = sqrtx * Float4(1.14f) - x * Float4(0.14f);
4425
4426                 return Min(Max(sRGB, Float4(0.0f)), Float4(1.0f));
4427         }
4428
4429         Float4 PixelRoutine::sRGBtoLinear(const Float4 &x)   // Approximates x^2.2
4430         {
4431                 Float4 linear = x * x;
4432                 linear = linear * Float4(0.73f) + linear * x * Float4(0.27f);
4433
4434                 return Min(Max(linear, Float4(0.0f)), Float4(1.0f));
4435         }
4436
4437         void PixelRoutine::MOV(Vector4s &dst, Vector4s &src0)
4438         {
4439                 dst.x = src0.x;
4440                 dst.y = src0.y;
4441                 dst.z = src0.z;
4442                 dst.w = src0.w;
4443         }
4444
4445         void PixelRoutine::ADD(Vector4s &dst, Vector4s &src0, Vector4s &src1)
4446         {
4447                 dst.x = AddSat(src0.x, src1.x);
4448                 dst.y = AddSat(src0.y, src1.y);
4449                 dst.z = AddSat(src0.z, src1.z);
4450                 dst.w = AddSat(src0.w, src1.w);
4451         }
4452
4453         void PixelRoutine::SUB(Vector4s &dst, Vector4s &src0, Vector4s &src1)
4454         {
4455                 dst.x = SubSat(src0.x, src1.x);
4456                 dst.y = SubSat(src0.y, src1.y);
4457                 dst.z = SubSat(src0.z, src1.z);
4458                 dst.w = SubSat(src0.w, src1.w);
4459         }
4460
4461         void PixelRoutine::MAD(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
4462         {
4463                 // FIXME: Long fixed-point multiply fixup
4464                 {dst.x = MulHigh(src0.x, src1.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, src2.x);}
4465                 {dst.y = MulHigh(src0.y, src1.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, src2.y);}
4466                 {dst.z = MulHigh(src0.z, src1.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, src2.z);}
4467                 {dst.w = MulHigh(src0.w, src1.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, src2.w);}
4468         }
4469
4470         void PixelRoutine::MUL(Vector4s &dst, Vector4s &src0, Vector4s &src1)
4471         {
4472                 // FIXME: Long fixed-point multiply fixup
4473                 {dst.x = MulHigh(src0.x, src1.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x);}
4474                 {dst.y = MulHigh(src0.y, src1.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y);}
4475                 {dst.z = MulHigh(src0.z, src1.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z);}
4476                 {dst.w = MulHigh(src0.w, src1.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w);}
4477         }
4478
4479         void PixelRoutine::DP3(Vector4s &dst, Vector4s &src0, Vector4s &src1)
4480         {
4481                 Short4 t0;
4482                 Short4 t1;
4483
4484                 // FIXME: Long fixed-point multiply fixup
4485                 t0 = MulHigh(src0.x, src1.x); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0);
4486                 t1 = MulHigh(src0.y, src1.y); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
4487                 t0 = AddSat(t0, t1);
4488                 t1 = MulHigh(src0.z, src1.z); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
4489                 t0 = AddSat(t0, t1);
4490
4491                 dst.x = t0;
4492                 dst.y = t0;
4493                 dst.z = t0;
4494                 dst.w = t0;
4495         }
4496
4497         void PixelRoutine::DP4(Vector4s &dst, Vector4s &src0, Vector4s &src1)
4498         {
4499                 Short4 t0;
4500                 Short4 t1;
4501
4502                 // FIXME: Long fixed-point multiply fixup
4503                 t0 = MulHigh(src0.x, src1.x); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0);
4504                 t1 = MulHigh(src0.y, src1.y); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
4505                 t0 = AddSat(t0, t1);
4506                 t1 = MulHigh(src0.z, src1.z); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
4507                 t0 = AddSat(t0, t1);
4508                 t1 = MulHigh(src0.w, src1.w); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
4509                 t0 = AddSat(t0, t1);
4510
4511                 dst.x = t0;
4512                 dst.y = t0;
4513                 dst.z = t0;
4514                 dst.w = t0;
4515         }
4516
4517         void PixelRoutine::LRP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
4518         {
4519                 // FIXME: Long fixed-point multiply fixup
4520                 {dst.x = SubSat(src1.x, src2.x); dst.x = MulHigh(dst.x, src0.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, src2.x);}
4521                 {dst.y = SubSat(src1.y, src2.y); dst.y = MulHigh(dst.y, src0.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, src2.y);}
4522                 {dst.z = SubSat(src1.z, src2.z); dst.z = MulHigh(dst.z, src0.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, src2.z);}
4523                 {dst.w = SubSat(src1.w, src2.w); dst.w = MulHigh(dst.w, src0.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, src2.w);}
4524         }
4525
4526         void PixelRoutine::TEXCOORD(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate)
4527         {
4528                 Float4 uw;
4529                 Float4 vw;
4530                 Float4 sw;
4531
4532                 if(state.interpolant[2 + coordinate].component & 0x01)
4533                 {
4534                         uw = Max(u, Float4(0.0f));
4535                         uw = Min(uw, Float4(1.0f));
4536                         dst.x = convertFixed12(uw);
4537                 }
4538                 else
4539                 {
4540                         dst.x = Short4(0x0000, 0x0000, 0x0000, 0x0000);
4541                 }
4542
4543                 if(state.interpolant[2 + coordinate].component & 0x02)
4544                 {
4545                         vw = Max(v, Float4(0.0f));
4546                         vw = Min(vw, Float4(1.0f));
4547                         dst.y = convertFixed12(vw);
4548                 }
4549                 else
4550                 {
4551                         dst.y = Short4(0x0000, 0x0000, 0x0000, 0x0000);
4552                 }
4553
4554                 if(state.interpolant[2 + coordinate].component & 0x04)
4555                 {
4556                         sw = Max(s, Float4(0.0f));
4557                         sw = Min(sw, Float4(1.0f));
4558                         dst.z = convertFixed12(sw);
4559                 }
4560                 else
4561                 {
4562                         dst.z = Short4(0x0000, 0x0000, 0x0000, 0x0000);
4563                 }
4564
4565                 dst.w = Short4(0x1000);
4566         }
4567
4568         void PixelRoutine::TEXCRD(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate, bool project)
4569         {
4570                 Float4 uw = u;
4571                 Float4 vw = v;
4572                 Float4 sw = s;
4573
4574                 if(project)
4575                 {
4576                         uw *= Rcp_pp(s);
4577                         vw *= Rcp_pp(s);
4578                 }
4579
4580                 if(state.interpolant[2 + coordinate].component & 0x01)
4581                 {
4582                         uw *= Float4(0x1000);
4583                         uw = Max(uw, Float4(-0x8000));
4584                         uw = Min(uw, Float4(0x7FFF));
4585                         dst.x = RoundShort4(uw);
4586                 }
4587                 else
4588                 {
4589                         dst.x = Short4(0x0000);
4590                 }
4591
4592                 if(state.interpolant[2 + coordinate].component & 0x02)
4593                 {
4594                         vw *= Float4(0x1000);
4595                         vw = Max(vw, Float4(-0x8000));
4596                         vw = Min(vw, Float4(0x7FFF));
4597                         dst.y = RoundShort4(vw);
4598                 }
4599                 else
4600                 {
4601                         dst.y = Short4(0x0000, 0x0000, 0x0000, 0x0000);
4602                 }
4603
4604                 if(state.interpolant[2 + coordinate].component & 0x04)
4605                 {
4606                         sw *= Float4(0x1000);
4607                         sw = Max(sw, Float4(-0x8000));
4608                         sw = Min(sw, Float4(0x7FFF));
4609                         dst.z = RoundShort4(sw);
4610                 }
4611                 else
4612                 {
4613                         dst.z = Short4(0x0000, 0x0000, 0x0000, 0x0000);
4614                 }
4615         }
4616
4617         void PixelRoutine::TEXDP3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src)
4618         {
4619                 TEXM3X3PAD(r, u, v, s, src, 0, false);
4620
4621                 Short4 t0 = RoundShort4(r.u_ * Float4(0x1000));
4622
4623                 dst.x = t0;
4624                 dst.y = t0;
4625                 dst.z = t0;
4626                 dst.w = t0;
4627         }
4628
4629         void PixelRoutine::TEXDP3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0)
4630         {
4631                 TEXM3X3PAD(r, u, v, s, src0, 0, false);
4632
4633                 r.v_ = Float4(0.0f);
4634                 r.w_ = Float4(0.0f);
4635
4636                 sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
4637         }
4638
4639         void PixelRoutine::TEXKILL(Int cMask[4], Float4 &u, Float4 &v, Float4 &s)
4640         {
4641                 Int kill = SignMask(CmpNLT(u, Float4(0.0f))) &
4642                            SignMask(CmpNLT(v, Float4(0.0f))) &
4643                            SignMask(CmpNLT(s, Float4(0.0f)));
4644
4645                 for(unsigned int q = 0; q < state.multiSample; q++)
4646                 {
4647                         cMask[q] &= kill;
4648                 }
4649         }
4650
4651         void PixelRoutine::TEXKILL(Int cMask[4], Vector4s &src)
4652         {
4653                 Short4 test = src.x | src.y | src.z;
4654                 Int kill = SignMask(Pack(test, test)) ^ 0x0000000F;
4655
4656                 for(unsigned int q = 0; q < state.multiSample; q++)
4657                 {
4658                         cMask[q] &= kill;
4659                 }
4660         }
4661
4662         void PixelRoutine::TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int sampler, bool project)
4663         {
4664                 sampleTexture(r, dst, sampler, u, v, s, s, project);
4665         }
4666
4667         void PixelRoutine::TEXLD(Registers &r, Vector4s &dst, Vector4s &src, int sampler, bool project)
4668         {
4669                 Float4 u = Float4(src.x) * Float4(1.0f / 0x0FFE);
4670                 Float4 v = Float4(src.y) * Float4(1.0f / 0x0FFE);
4671                 Float4 s = Float4(src.z) * Float4(1.0f / 0x0FFE);
4672
4673                 sampleTexture(r, dst, sampler, u, v, s, s, project);
4674         }
4675
4676         void PixelRoutine::TEXBEM(Registers &r, Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage)
4677         {
4678                 Float4 du = Float4(src.x) * Float4(1.0f / 0x0FFE);
4679                 Float4 dv = Float4(src.y) * Float4(1.0f / 0x0FFE);
4680
4681                 Float4 du2 = du;
4682                 Float4 dv2 = dv;
4683
4684                 du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
4685                 dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
4686                 du += dv2;
4687                 dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
4688                 du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
4689                 dv += du2;
4690
4691                 Float4 u_ = u + du;
4692                 Float4 v_ = v + dv;
4693
4694                 sampleTexture(r, dst, stage, u_, v_, s, s);
4695         }
4696
4697         void PixelRoutine::TEXBEML(Registers &r, Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage)
4698         {
4699                 Float4 du = Float4(src.x) * Float4(1.0f / 0x0FFE);
4700                 Float4 dv = Float4(src.y) * Float4(1.0f / 0x0FFE);
4701
4702                 Float4 du2 = du;
4703                 Float4 dv2 = dv;
4704
4705                 du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
4706                 dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
4707                 du += dv2;
4708                 dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
4709                 du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
4710                 dv += du2;
4711
4712                 Float4 u_ = u + du;
4713                 Float4 v_ = v + dv;
4714
4715                 sampleTexture(r, dst, stage, u_, v_, s, s);
4716
4717                 Short4 L;
4718
4719                 L = src.z;
4720                 L = MulHigh(L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceScale4)));
4721                 L = L << 4;
4722                 L = AddSat(L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceOffset4)));
4723                 L = Max(L, Short4(0x0000, 0x0000, 0x0000, 0x0000));
4724                 L = Min(L, Short4(0x1000));
4725
4726                 dst.x = MulHigh(dst.x, L); dst.x = dst.x << 4;
4727                 dst.y = MulHigh(dst.y, L); dst.y = dst.y << 4;
4728                 dst.z = MulHigh(dst.z, L); dst.z = dst.z << 4;
4729         }
4730
4731         void PixelRoutine::TEXREG2AR(Registers &r, Vector4s &dst, Vector4s &src0, int stage)
4732         {
4733                 Float4 u = Float4(src0.w) * Float4(1.0f / 0x0FFE);
4734                 Float4 v = Float4(src0.x) * Float4(1.0f / 0x0FFE);
4735                 Float4 s = Float4(src0.z) * Float4(1.0f / 0x0FFE);
4736
4737                 sampleTexture(r, dst, stage, u, v, s, s);
4738         }
4739
4740         void PixelRoutine::TEXREG2GB(Registers &r, Vector4s &dst, Vector4s &src0, int stage)
4741         {
4742                 Float4 u = Float4(src0.y) * Float4(1.0f / 0x0FFE);
4743                 Float4 v = Float4(src0.z) * Float4(1.0f / 0x0FFE);
4744                 Float4 s = v;
4745
4746                 sampleTexture(r, dst, stage, u, v, s, s);
4747         }
4748
4749         void PixelRoutine::TEXREG2RGB(Registers &r, Vector4s &dst, Vector4s &src0, int stage)
4750         {
4751                 Float4 u = Float4(src0.x) * Float4(1.0f / 0x0FFE);
4752                 Float4 v = Float4(src0.y) * Float4(1.0f / 0x0FFE);
4753                 Float4 s = Float4(src0.z) * Float4(1.0f / 0x0FFE);
4754
4755                 sampleTexture(r, dst, stage, u, v, s, s);
4756         }
4757
4758         void PixelRoutine::TEXM3X2DEPTH(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling)
4759         {
4760                 TEXM3X2PAD(r, u, v, s, src, 1, signedScaling);
4761
4762                 // z / w
4763                 r.u_ *= Rcp_pp(r.v_);   // FIXME: Set result to 1.0 when division by zero
4764
4765                 r.oDepth = r.u_;
4766         }
4767
4768         void PixelRoutine::TEXM3X2PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
4769         {
4770                 TEXM3X3PAD(r, u, v, s, src0, component, signedScaling);
4771         }
4772
4773         void PixelRoutine::TEXM3X2TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
4774         {
4775                 TEXM3X2PAD(r, u, v, s, src0, 1, signedScaling);
4776
4777                 r.w_ = Float4(0.0f);
4778
4779                 sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
4780         }
4781
4782         void PixelRoutine::TEXM3X3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling)
4783         {
4784                 TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
4785
4786                 dst.x = RoundShort4(r.u_ * Float4(0x1000));
4787                 dst.y = RoundShort4(r.v_ * Float4(0x1000));
4788                 dst.z = RoundShort4(r.w_ * Float4(0x1000));
4789                 dst.w = Short4(0x1000);
4790         }
4791
4792         void PixelRoutine::TEXM3X3PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
4793         {
4794                 if(component == 0 || previousScaling != signedScaling)   // FIXME: Other source modifiers?
4795                 {
4796                         r.U = Float4(src0.x);
4797                         r.V = Float4(src0.y);
4798                         r.W = Float4(src0.z);
4799
4800                         previousScaling = signedScaling;
4801                 }
4802
4803                 Float4 x = r.U * u + r.V * v + r.W * s;
4804
4805                 x *= Float4(1.0f / 0x1000);
4806
4807                 switch(component)
4808                 {
4809                 case 0: r.u_ = x; break;
4810                 case 1: r.v_ = x; break;
4811                 case 2: r.w_ = x; break;
4812                 default: ASSERT(false);
4813                 }
4814         }
4815
4816         void PixelRoutine::TEXM3X3SPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1)
4817         {
4818                 TEXM3X3PAD(r, u, v, s, src0, 2, false);
4819
4820                 Float4 E[3];   // Eye vector
4821
4822                 E[0] = Float4(src1.x) * Float4(1.0f / 0x0FFE);
4823                 E[1] = Float4(src1.y) * Float4(1.0f / 0x0FFE);
4824                 E[2] = Float4(src1.z) * Float4(1.0f / 0x0FFE);
4825
4826                 // Reflection
4827                 Float4 u__;
4828                 Float4 v__;
4829                 Float4 w__;
4830
4831                 // (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
4832                 u__ = r.u_ * E[0];
4833                 v__ = r.v_ * E[1];
4834                 w__ = r.w_ * E[2];
4835                 u__ += v__ + w__;
4836                 u__ += u__;
4837                 v__ = u__;
4838                 w__ = u__;
4839                 u__ *= r.u_;
4840                 v__ *= r.v_;
4841                 w__ *= r.w_;
4842                 r.u_ *= r.u_;
4843                 r.v_ *= r.v_;
4844                 r.w_ *= r.w_;
4845                 r.u_ += r.v_ + r.w_;
4846                 u__ -= E[0] * r.u_;
4847                 v__ -= E[1] * r.u_;
4848                 w__ -= E[2] * r.u_;
4849
4850                 sampleTexture(r, dst, stage,  u__, v__, w__, w__);
4851         }
4852
4853         void PixelRoutine::TEXM3X3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
4854         {
4855                 TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
4856
4857                 sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
4858         }
4859
4860         void PixelRoutine::TEXM3X3VSPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0)
4861         {
4862                 TEXM3X3PAD(r, u, v, s, src0, 2, false);
4863
4864                 Float4 E[3];   // Eye vector
4865
4866                 E[0] = r.vf[2 + stage - 2].w;
4867                 E[1] = r.vf[2 + stage - 1].w;
4868                 E[2] = r.vf[2 + stage - 0].w;
4869
4870                 // Reflection
4871                 Float4 u__;
4872                 Float4 v__;
4873                 Float4 w__;
4874
4875                 // (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
4876                 u__ = r.u_ * E[0];
4877                 v__ = r.v_ * E[1];
4878                 w__ = r.w_ * E[2];
4879                 u__ += v__ + w__;
4880                 u__ += u__;
4881                 v__ = u__;
4882                 w__ = u__;
4883                 u__ *= r.u_;
4884                 v__ *= r.v_;
4885                 w__ *= r.w_;
4886                 r.u_ *= r.u_;
4887                 r.v_ *= r.v_;
4888                 r.w_ *= r.w_;
4889                 r.u_ += r.v_ + r.w_;
4890                 u__ -= E[0] * r.u_;
4891                 v__ -= E[1] * r.u_;
4892                 w__ -= E[2] * r.u_;
4893
4894                 sampleTexture(r, dst, stage, u__, v__, w__, w__);
4895         }
4896
4897         void PixelRoutine::TEXDEPTH(Registers &r)
4898         {
4899                 r.u_ = Float4(r.rs[5].x);
4900                 r.v_ = Float4(r.rs[5].y);
4901
4902                 // z / w
4903                 r.u_ *= Rcp_pp(r.v_);   // FIXME: Set result to 1.0 when division by zero
4904
4905                 r.oDepth = r.u_;
4906         }
4907
4908         void PixelRoutine::CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
4909         {
4910                 {Short4 t0; t0 = src0.x; t0 = CmpGT(t0, Short4(0x0800, 0x0800, 0x0800, 0x0800)); Short4 t1; t1 = src1.x; t1 = t1 & t0; t0 = ~t0 & src2.x; t0 = t0 | t1; dst.x = t0;};
4911                 {Short4 t0; t0 = src0.y; t0 = CmpGT(t0, Short4(0x0800, 0x0800, 0x0800, 0x0800)); Short4 t1; t1 = src1.y; t1 = t1 & t0; t0 = ~t0 & src2.y; t0 = t0 | t1; dst.y = t0;};
4912                 {Short4 t0; t0 = src0.z; t0 = CmpGT(t0, Short4(0x0800, 0x0800, 0x0800, 0x0800)); Short4 t1; t1 = src1.z; t1 = t1 & t0; t0 = ~t0 & src2.z; t0 = t0 | t1; dst.z = t0;};
4913                 {Short4 t0; t0 = src0.w; t0 = CmpGT(t0, Short4(0x0800, 0x0800, 0x0800, 0x0800)); Short4 t1; t1 = src1.w; t1 = t1 & t0; t0 = ~t0 & src2.w; t0 = t0 | t1; dst.w = t0;};
4914         }
4915
4916         void PixelRoutine::CMP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
4917         {
4918                 {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.x); Short4 t1; t1 = src2.x; t1 &= t0; t0 = ~t0 & src1.x; t0 |= t1; dst.x = t0;};
4919                 {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.y); Short4 t1; t1 = src2.y; t1 &= t0; t0 = ~t0 & src1.y; t0 |= t1; dst.y = t0;};
4920                 {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.z); Short4 t1; t1 = src2.z; t1 &= t0; t0 = ~t0 & src1.z; t0 |= t1; dst.z = t0;};
4921                 {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.w); Short4 t1; t1 = src2.w; t1 &= t0; t0 = ~t0 & src1.w; t0 |= t1; dst.w = t0;};
4922         }
4923
4924         void PixelRoutine::BEM(Registers &r, Vector4s &dst, Vector4s &src0, Vector4s &src1, int stage)
4925         {
4926                 Short4 t0;
4927                 Short4 t1;
4928
4929                 // dst.x = src0.x + BUMPENVMAT00(stage) * src1.x + BUMPENVMAT10(stage) * src1.y
4930                 t0 = MulHigh(src1.x, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[0][0]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
4931                 t1 = MulHigh(src1.y, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[1][0]))); t1 = t1 << 4;   // FIXME: Matrix components range? Overflow hazard.
4932                 t0 = AddSat(t0, t1);
4933                 t0 = AddSat(t0, src0.x);
4934                 dst.x = t0;
4935
4936                 // dst.y = src0.y + BUMPENVMAT01(stage) * src1.x + BUMPENVMAT11(stage) * src1.y
4937                 t0 = MulHigh(src1.x, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[0][1]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
4938                 t1 = MulHigh(src1.y, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[1][1]))); t1 = t1 << 4;   // FIXME: Matrix components range? Overflow hazard.
4939                 t0 = AddSat(t0, t1);
4940                 t0 = AddSat(t0, src0.y);
4941                 dst.y = t0;
4942         }
4943
4944         void PixelRoutine::M3X2(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
4945         {
4946                 Vector4f row0 = fetchRegisterF(r, src1, 0);
4947                 Vector4f row1 = fetchRegisterF(r, src1, 1);
4948
4949                 dst.x = dot3(src0, row0);
4950                 dst.y = dot3(src0, row1);
4951         }
4952
4953         void PixelRoutine::M3X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
4954         {
4955                 Vector4f row0 = fetchRegisterF(r, src1, 0);
4956                 Vector4f row1 = fetchRegisterF(r, src1, 1);
4957                 Vector4f row2 = fetchRegisterF(r, src1, 2);
4958
4959                 dst.x = dot3(src0, row0);
4960                 dst.y = dot3(src0, row1);
4961                 dst.z = dot3(src0, row2);
4962         }
4963
4964         void PixelRoutine::M3X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
4965         {
4966                 Vector4f row0 = fetchRegisterF(r, src1, 0);
4967                 Vector4f row1 = fetchRegisterF(r, src1, 1);
4968                 Vector4f row2 = fetchRegisterF(r, src1, 2);
4969                 Vector4f row3 = fetchRegisterF(r, src1, 3);
4970
4971                 dst.x = dot3(src0, row0);
4972                 dst.y = dot3(src0, row1);
4973                 dst.z = dot3(src0, row2);
4974                 dst.w = dot3(src0, row3);
4975         }
4976
4977         void PixelRoutine::M4X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
4978         {
4979                 Vector4f row0 = fetchRegisterF(r, src1, 0);
4980                 Vector4f row1 = fetchRegisterF(r, src1, 1);
4981                 Vector4f row2 = fetchRegisterF(r, src1, 2);
4982
4983                 dst.x = dot4(src0, row0);
4984                 dst.y = dot4(src0, row1);
4985                 dst.z = dot4(src0, row2);
4986         }
4987
4988         void PixelRoutine::M4X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
4989         {
4990                 Vector4f row0 = fetchRegisterF(r, src1, 0);
4991                 Vector4f row1 = fetchRegisterF(r, src1, 1);
4992                 Vector4f row2 = fetchRegisterF(r, src1, 2);
4993                 Vector4f row3 = fetchRegisterF(r, src1, 3);
4994
4995                 dst.x = dot4(src0, row0);
4996                 dst.y = dot4(src0, row1);
4997                 dst.z = dot4(src0, row2);
4998                 dst.w = dot4(src0, row3);
4999         }
5000
5001         void PixelRoutine::TEXLD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
5002         {
5003                 Vector4f tmp;
5004                 sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias);
5005
5006                 dst.x = tmp[(src1.swizzle >> 0) & 0x3];
5007                 dst.y = tmp[(src1.swizzle >> 2) & 0x3];
5008                 dst.z = tmp[(src1.swizzle >> 4) & 0x3];
5009                 dst.w = tmp[(src1.swizzle >> 6) & 0x3];
5010         }
5011
5012         void PixelRoutine::TEXLDD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2,  Vector4f &src3, bool project, bool bias)
5013         {
5014                 Vector4f tmp;
5015                 sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src2, src3, project, bias, true);
5016
5017                 dst.x = tmp[(src1.swizzle >> 0) & 0x3];
5018                 dst.y = tmp[(src1.swizzle >> 2) & 0x3];
5019                 dst.z = tmp[(src1.swizzle >> 4) & 0x3];
5020                 dst.w = tmp[(src1.swizzle >> 6) & 0x3];
5021         }
5022
5023         void PixelRoutine::TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
5024         {
5025                 Vector4f tmp;
5026                 sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias, false, true);
5027
5028                 dst.x = tmp[(src1.swizzle >> 0) & 0x3];
5029                 dst.y = tmp[(src1.swizzle >> 2) & 0x3];
5030                 dst.z = tmp[(src1.swizzle >> 4) & 0x3];
5031                 dst.w = tmp[(src1.swizzle >> 6) & 0x3];
5032         }
5033
5034         void PixelRoutine::TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask)
5035         {
5036                 Int kill = -1;
5037
5038                 if(mask & 0x1) kill &= SignMask(CmpNLT(src.x, Float4(0.0f)));
5039                 if(mask & 0x2) kill &= SignMask(CmpNLT(src.y, Float4(0.0f)));
5040                 if(mask & 0x4) kill &= SignMask(CmpNLT(src.z, Float4(0.0f)));
5041                 if(mask & 0x8) kill &= SignMask(CmpNLT(src.w, Float4(0.0f)));
5042
5043                 // FIXME: Dynamic branching affects TEXKILL?
5044         //      if(shader->containsDynamicBranching())
5045         //      {
5046         //              kill = ~SignMask(enableMask(r));
5047         //      }
5048
5049                 for(unsigned int q = 0; q < state.multiSample; q++)
5050                 {
5051                         cMask[q] &= kill;
5052                 }
5053
5054                 // FIXME: Branch to end of shader if all killed?
5055         }
5056
5057         void PixelRoutine::DISCARD(Registers &r, Int cMask[4], const Shader::Instruction *instruction)
5058         {
5059                 Int kill = 0;
5060
5061                 if(shader->containsDynamicBranching())
5062                 {
5063                         kill = ~SignMask(enableMask(r, instruction));
5064                 }
5065
5066                 for(unsigned int q = 0; q < state.multiSample; q++)
5067                 {
5068                         cMask[q] &= kill;
5069                 }
5070
5071                 // FIXME: Branch to end of shader if all killed?
5072         }
5073
5074         void PixelRoutine::DFDX(Vector4f &dst, Vector4f &src)
5075         {
5076                 dst.x = src.x.yyww - src.x.xxzz;
5077                 dst.y = src.y.yyww - src.y.xxzz;
5078                 dst.z = src.z.yyww - src.z.xxzz;
5079                 dst.w = src.w.yyww - src.w.xxzz;
5080         }
5081
5082         void PixelRoutine::DFDY(Vector4f &dst, Vector4f &src)
5083         {
5084                 dst.x = src.x.zwzw - src.x.xyxy;
5085                 dst.y = src.y.zwzw - src.y.xyxy;
5086                 dst.z = src.z.zwzw - src.z.xyxy;
5087                 dst.w = src.w.zwzw - src.w.xyxy;
5088         }
5089
5090         void PixelRoutine::FWIDTH(Vector4f &dst, Vector4f &src)
5091         {
5092                 // abs(dFdx(src)) + abs(dFdy(src));
5093                 dst.x = Abs(src.x.yyww - src.x.xxzz) + Abs(src.x.zwzw - src.x.xyxy);
5094                 dst.y = Abs(src.y.yyww - src.x.xxzz) + Abs(src.y.zwzw - src.y.xyxy);
5095                 dst.z = Abs(src.z.yyww - src.x.xxzz) + Abs(src.z.zwzw - src.z.xyxy);
5096                 dst.w = Abs(src.w.yyww - src.x.xxzz) + Abs(src.w.zwzw - src.w.xyxy);
5097         }
5098
5099         void PixelRoutine::BREAK(Registers &r)
5100         {
5101                 llvm::BasicBlock *deadBlock = Nucleus::createBasicBlock();
5102                 llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
5103
5104                 if(breakDepth == 0)
5105                 {
5106                         r.enableIndex = r.enableIndex - breakDepth;
5107                         Nucleus::createBr(endBlock);
5108                 }
5109                 else
5110                 {
5111                         r.enableBreak = r.enableBreak & ~r.enableStack[r.enableIndex];
5112                         Bool allBreak = SignMask(r.enableBreak) == 0x0;
5113
5114                         r.enableIndex = r.enableIndex - breakDepth;
5115                         branch(allBreak, endBlock, deadBlock);
5116                 }
5117
5118                 Nucleus::setInsertBlock(deadBlock);
5119                 r.enableIndex = r.enableIndex + breakDepth;
5120         }
5121
5122         void PixelRoutine::BREAKC(Registers &r, Vector4f &src0, Vector4f &src1, Control control)
5123         {
5124                 Int4 condition;
5125
5126                 switch(control)
5127                 {
5128                 case Shader::CONTROL_GT: condition = CmpNLE(src0.x,  src1.x);   break;
5129                 case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x);             break;
5130                 case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x);    break;
5131                 case Shader::CONTROL_LT: condition = CmpLT(src0.x,  src1.x);    break;
5132                 case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x);    break;
5133                 case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x);             break;
5134                 default:
5135                         ASSERT(false);
5136                 }
5137
5138                 BREAK(r, condition);
5139         }
5140
5141         void PixelRoutine::BREAKP(Registers &r, const Src &predicateRegister)   // FIXME: Factor out parts common with BREAKC
5142         {
5143                 Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
5144
5145                 if(predicateRegister.modifier == Shader::MODIFIER_NOT)
5146                 {
5147                         condition = ~condition;
5148                 }
5149
5150                 BREAK(r, condition);
5151         }
5152
5153         void PixelRoutine::BREAK(Registers &r, Int4 &condition)
5154         {
5155                 condition &= r.enableStack[r.enableIndex];
5156
5157                 llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
5158                 llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
5159
5160                 r.enableBreak = r.enableBreak & ~condition;
5161                 Bool allBreak = SignMask(r.enableBreak) == 0x0;
5162
5163                 r.enableIndex = r.enableIndex - breakDepth;
5164                 branch(allBreak, endBlock, continueBlock);
5165
5166                 Nucleus::setInsertBlock(continueBlock);
5167                 r.enableIndex = r.enableIndex + breakDepth;
5168         }
5169
5170         void PixelRoutine::CONTINUE(Registers &r)
5171         {
5172                 r.enableContinue = r.enableContinue & ~r.enableStack[r.enableIndex];
5173         }
5174
5175         void PixelRoutine::TEST()
5176         {
5177                 whileTest = true;
5178         }
5179
5180         void PixelRoutine::CALL(Registers &r, int labelIndex, int callSiteIndex)
5181         {
5182                 if(!labelBlock[labelIndex])
5183                 {
5184                         labelBlock[labelIndex] = Nucleus::createBasicBlock();
5185                 }
5186
5187                 if(callRetBlock[labelIndex].size() > 1)
5188                 {
5189                         r.callStack[r.stackIndex++] = UInt(callSiteIndex);
5190                 }
5191
5192                 Int4 restoreLeave = r.enableLeave;
5193
5194                 Nucleus::createBr(labelBlock[labelIndex]);
5195                 Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
5196
5197                 r.enableLeave = restoreLeave;
5198         }
5199
5200         void PixelRoutine::CALLNZ(Registers &r, int labelIndex, int callSiteIndex, const Src &src)
5201         {
5202                 if(src.type == Shader::PARAMETER_CONSTBOOL)
5203                 {
5204                         CALLNZb(r, labelIndex, callSiteIndex, src);
5205                 }
5206                 else if(src.type == Shader::PARAMETER_PREDICATE)
5207                 {
5208                         CALLNZp(r, labelIndex, callSiteIndex, src);
5209                 }
5210                 else ASSERT(false);
5211         }
5212
5213         void PixelRoutine::CALLNZb(Registers &r, int labelIndex, int callSiteIndex, const Src &boolRegister)
5214         {
5215                 Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,ps.b[boolRegister.index])) != Byte(0));   // FIXME
5216
5217                 if(boolRegister.modifier == Shader::MODIFIER_NOT)
5218                 {
5219                         condition = !condition;
5220                 }
5221
5222                 if(!labelBlock[labelIndex])
5223                 {
5224                         labelBlock[labelIndex] = Nucleus::createBasicBlock();
5225                 }
5226
5227                 if(callRetBlock[labelIndex].size() > 1)
5228                 {
5229                         r.callStack[r.stackIndex++] = UInt(callSiteIndex);
5230                 }
5231
5232                 Int4 restoreLeave = r.enableLeave;
5233
5234                 branch(condition, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
5235                 Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
5236
5237                 r.enableLeave = restoreLeave;
5238         }
5239
5240         void PixelRoutine::CALLNZp(Registers &r, int labelIndex, int callSiteIndex, const Src &predicateRegister)
5241         {
5242                 Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
5243
5244                 if(predicateRegister.modifier == Shader::MODIFIER_NOT)
5245                 {
5246                         condition = ~condition;
5247                 }
5248
5249                 condition &= r.enableStack[r.enableIndex];
5250
5251                 if(!labelBlock[labelIndex])
5252                 {
5253                         labelBlock[labelIndex] = Nucleus::createBasicBlock();
5254                 }
5255
5256                 if(callRetBlock[labelIndex].size() > 1)
5257                 {
5258                         r.callStack[r.stackIndex++] = UInt(callSiteIndex);
5259                 }
5260
5261                 r.enableIndex++;
5262                 r.enableStack[r.enableIndex] = condition;
5263                 Int4 restoreLeave = r.enableLeave;
5264
5265                 Bool notAllFalse = SignMask(condition) != 0;
5266                 branch(notAllFalse, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
5267                 Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
5268
5269                 r.enableIndex--;
5270                 r.enableLeave = restoreLeave;
5271         }
5272
5273         void PixelRoutine::ELSE(Registers &r)
5274         {
5275                 ifDepth--;
5276
5277                 llvm::BasicBlock *falseBlock = ifFalseBlock[ifDepth];
5278                 llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
5279
5280                 if(isConditionalIf[ifDepth])
5281                 {
5282                         Int4 condition = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
5283                         Bool notAllFalse = SignMask(condition) != 0;
5284
5285                         branch(notAllFalse, falseBlock, endBlock);
5286
5287                         r.enableStack[r.enableIndex] = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
5288                 }
5289                 else
5290                 {
5291                         Nucleus::createBr(endBlock);
5292                         Nucleus::setInsertBlock(falseBlock);
5293                 }
5294
5295                 ifFalseBlock[ifDepth] = endBlock;
5296
5297                 ifDepth++;
5298         }
5299
5300         void PixelRoutine::ENDIF(Registers &r)
5301         {
5302                 ifDepth--;
5303
5304                 llvm::BasicBlock *endBlock = ifFalseBlock[ifDepth];
5305
5306                 Nucleus::createBr(endBlock);
5307                 Nucleus::setInsertBlock(endBlock);
5308
5309                 if(isConditionalIf[ifDepth])
5310                 {
5311                         breakDepth--;
5312                         r.enableIndex--;
5313                 }
5314         }
5315
5316         void PixelRoutine::ENDLOOP(Registers &r)
5317         {
5318                 loopRepDepth--;
5319
5320                 r.aL[r.loopDepth] = r.aL[r.loopDepth] + r.increment[r.loopDepth];   // FIXME: +=
5321
5322                 llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
5323                 llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
5324
5325                 Nucleus::createBr(testBlock);
5326                 Nucleus::setInsertBlock(endBlock);
5327
5328                 r.loopDepth--;
5329                 r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
5330         }
5331
5332         void PixelRoutine::ENDREP(Registers &r)
5333         {
5334                 loopRepDepth--;
5335
5336                 llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
5337                 llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
5338
5339                 Nucleus::createBr(testBlock);
5340                 Nucleus::setInsertBlock(endBlock);
5341
5342                 r.loopDepth--;
5343                 r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
5344         }
5345
5346         void PixelRoutine::ENDWHILE(Registers &r)
5347         {
5348                 loopRepDepth--;
5349
5350                 llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
5351                 llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
5352
5353                 Nucleus::createBr(testBlock);
5354                 Nucleus::setInsertBlock(endBlock);
5355
5356                 r.enableIndex--;
5357                 r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
5358                 whileTest = false;
5359         }
5360
5361         void PixelRoutine::IF(Registers &r, const Src &src)
5362         {
5363                 if(src.type == Shader::PARAMETER_CONSTBOOL)
5364                 {
5365                         IFb(r, src);
5366                 }
5367                 else if(src.type == Shader::PARAMETER_PREDICATE)
5368                 {
5369                         IFp(r, src);
5370                 }
5371                 else
5372                 {
5373                         Int4 condition = As<Int4>(fetchRegisterF(r, src).x);
5374                         IF(r, condition);
5375                 }
5376         }
5377
5378         void PixelRoutine::IFb(Registers &r, const Src &boolRegister)
5379         {
5380                 ASSERT(ifDepth < 24 + 4);
5381
5382                 Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,ps.b[boolRegister.index])) != Byte(0));   // FIXME
5383
5384                 if(boolRegister.modifier == Shader::MODIFIER_NOT)
5385                 {
5386                         condition = !condition;
5387                 }
5388
5389                 llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
5390                 llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
5391
5392                 branch(condition, trueBlock, falseBlock);
5393
5394                 isConditionalIf[ifDepth] = false;
5395                 ifFalseBlock[ifDepth] = falseBlock;
5396
5397                 ifDepth++;
5398         }
5399
5400         void PixelRoutine::IFp(Registers &r, const Src &predicateRegister)
5401         {
5402                 Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
5403
5404                 if(predicateRegister.modifier == Shader::MODIFIER_NOT)
5405                 {
5406                         condition = ~condition;
5407                 }
5408
5409                 IF(r, condition);
5410         }
5411
5412         void PixelRoutine::IFC(Registers &r, Vector4f &src0, Vector4f &src1, Control control)
5413         {
5414                 Int4 condition;
5415
5416                 switch(control)
5417                 {
5418                 case Shader::CONTROL_GT: condition = CmpNLE(src0.x,  src1.x);   break;
5419                 case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x);             break;
5420                 case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x);    break;
5421                 case Shader::CONTROL_LT: condition = CmpLT(src0.x,  src1.x);    break;
5422                 case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x);    break;
5423                 case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x);             break;
5424                 default:
5425                         ASSERT(false);
5426                 }
5427
5428                 IF(r, condition);
5429         }
5430
5431         void PixelRoutine::IF(Registers &r, Int4 &condition)
5432         {
5433                 condition &= r.enableStack[r.enableIndex];
5434
5435                 r.enableIndex++;
5436                 r.enableStack[r.enableIndex] = condition;
5437
5438                 llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
5439                 llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
5440
5441                 Bool notAllFalse = SignMask(condition) != 0;
5442
5443                 branch(notAllFalse, trueBlock, falseBlock);
5444
5445                 isConditionalIf[ifDepth] = true;
5446                 ifFalseBlock[ifDepth] = falseBlock;
5447
5448                 ifDepth++;
5449                 breakDepth++;
5450         }
5451
5452         void PixelRoutine::LABEL(int labelIndex)
5453         {
5454                 if(!labelBlock[labelIndex])
5455                 {
5456                         labelBlock[labelIndex] = Nucleus::createBasicBlock();
5457                 }
5458
5459                 Nucleus::setInsertBlock(labelBlock[labelIndex]);
5460                 currentLabel = labelIndex;
5461         }
5462
5463         void PixelRoutine::LOOP(Registers &r, const Src &integerRegister)
5464         {
5465                 r.loopDepth++;
5466
5467                 r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][0]));
5468                 r.aL[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][1]));
5469                 r.increment[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][2]));
5470
5471         //      If(r.increment[r.loopDepth] == 0)
5472         //      {
5473         //              r.increment[r.loopDepth] = 1;
5474         //      }
5475
5476                 llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
5477                 llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
5478                 llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
5479
5480                 loopRepTestBlock[loopRepDepth] = testBlock;
5481                 loopRepEndBlock[loopRepDepth] = endBlock;
5482
5483                 // FIXME: jump(testBlock)
5484                 Nucleus::createBr(testBlock);
5485                 Nucleus::setInsertBlock(testBlock);
5486
5487                 branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
5488                 Nucleus::setInsertBlock(loopBlock);
5489
5490                 r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1;   // FIXME: --
5491
5492                 loopRepDepth++;
5493                 breakDepth = 0;
5494         }
5495
5496         void PixelRoutine::REP(Registers &r, const Src &integerRegister)
5497         {
5498                 r.loopDepth++;
5499
5500                 r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][0]));
5501                 r.aL[r.loopDepth] = r.aL[r.loopDepth - 1];
5502
5503                 llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
5504                 llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
5505                 llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
5506
5507                 loopRepTestBlock[loopRepDepth] = testBlock;
5508                 loopRepEndBlock[loopRepDepth] = endBlock;
5509
5510                 // FIXME: jump(testBlock)
5511                 Nucleus::createBr(testBlock);
5512                 Nucleus::setInsertBlock(testBlock);
5513
5514                 branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
5515                 Nucleus::setInsertBlock(loopBlock);
5516
5517                 r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1;   // FIXME: --
5518
5519                 loopRepDepth++;
5520                 breakDepth = 0;
5521         }
5522
5523         void PixelRoutine::WHILE(Registers &r, const Src &temporaryRegister)
5524         {
5525                 r.enableIndex++;
5526
5527                 llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
5528                 llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
5529                 llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
5530
5531                 loopRepTestBlock[loopRepDepth] = testBlock;
5532                 loopRepEndBlock[loopRepDepth] = endBlock;
5533
5534                 Int4 restoreBreak = r.enableBreak;
5535                 Int4 restoreContinue = r.enableContinue;
5536
5537                 // FIXME: jump(testBlock)
5538                 Nucleus::createBr(testBlock);
5539                 Nucleus::setInsertBlock(testBlock);
5540                 r.enableContinue = restoreContinue;
5541
5542                 const Vector4f &src = fetchRegisterF(r, temporaryRegister);
5543                 Int4 condition = As<Int4>(src.x);
5544                 condition &= r.enableStack[r.enableIndex - 1];
5545                 r.enableStack[r.enableIndex] = condition;
5546
5547                 Bool notAllFalse = SignMask(condition) != 0;
5548                 branch(notAllFalse, loopBlock, endBlock);
5549
5550                 Nucleus::setInsertBlock(endBlock);
5551                 r.enableBreak = restoreBreak;
5552
5553                 Nucleus::setInsertBlock(loopBlock);
5554
5555                 loopRepDepth++;
5556                 breakDepth = 0;
5557         }
5558
5559         void PixelRoutine::RET(Registers &r)
5560         {
5561                 if(currentLabel == -1)
5562                 {
5563                         returnBlock = Nucleus::createBasicBlock();
5564                         Nucleus::createBr(returnBlock);
5565                 }
5566                 else
5567                 {
5568                         llvm::BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
5569
5570                         if(callRetBlock[currentLabel].size() > 1)   // Pop the return destination from the call stack
5571                         {
5572                                 // FIXME: Encapsulate
5573                                 UInt index = r.callStack[--r.stackIndex];
5574
5575                                 llvm::Value *value = index.loadValue();
5576                                 llvm::Value *switchInst = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size());
5577
5578                                 for(unsigned int i = 0; i < callRetBlock[currentLabel].size(); i++)
5579                                 {
5580                                         Nucleus::addSwitchCase(switchInst, i, callRetBlock[currentLabel][i]);
5581                                 }
5582                         }
5583                         else if(callRetBlock[currentLabel].size() == 1)   // Jump directly to the unique return destination
5584                         {
5585                                 Nucleus::createBr(callRetBlock[currentLabel][0]);
5586                         }
5587                         else   // Function isn't called
5588                         {
5589                                 Nucleus::createBr(unreachableBlock);
5590                         }
5591
5592                         Nucleus::setInsertBlock(unreachableBlock);
5593                         Nucleus::createUnreachable();
5594                 }
5595         }
5596
5597         void PixelRoutine::LEAVE(Registers &r)
5598         {
5599                 r.enableLeave = r.enableLeave & ~r.enableStack[r.enableIndex];
5600
5601                 // FIXME: Return from function if all instances left
5602                 // FIXME: Use enableLeave in other control-flow constructs
5603         }
5604
5605         void PixelRoutine::writeDestination(Registers &r, Vector4s &d, const Dst &dst)
5606         {
5607                 switch(dst.type)
5608                 {
5609                 case Shader::PARAMETER_TEMP:
5610                         if(dst.mask & 0x1) r.rs[dst.index].x = d.x;
5611                         if(dst.mask & 0x2) r.rs[dst.index].y = d.y;
5612                         if(dst.mask & 0x4) r.rs[dst.index].z = d.z;
5613                         if(dst.mask & 0x8) r.rs[dst.index].w = d.w;
5614                         break;
5615                 case Shader::PARAMETER_INPUT:
5616                         if(dst.mask & 0x1) r.vs[dst.index].x = d.x;
5617                         if(dst.mask & 0x2) r.vs[dst.index].y = d.y;
5618                         if(dst.mask & 0x4) r.vs[dst.index].z = d.z;
5619                         if(dst.mask & 0x8) r.vs[dst.index].w = d.w;
5620                         break;
5621                 case Shader::PARAMETER_CONST:                   ASSERT(false);  break;
5622                 case Shader::PARAMETER_TEXTURE:
5623                         if(dst.mask & 0x1) r.ts[dst.index].x = d.x;
5624                         if(dst.mask & 0x2) r.ts[dst.index].y = d.y;
5625                         if(dst.mask & 0x4) r.ts[dst.index].z = d.z;
5626                         if(dst.mask & 0x8) r.ts[dst.index].w = d.w;
5627                         break;
5628                 case Shader::PARAMETER_COLOROUT:
5629                         if(dst.mask & 0x1) r.vs[dst.index].x = d.x;
5630                         if(dst.mask & 0x2) r.vs[dst.index].y = d.y;
5631                         if(dst.mask & 0x4) r.vs[dst.index].z = d.z;
5632                         if(dst.mask & 0x8) r.vs[dst.index].w = d.w;
5633                         break;
5634                 default:
5635                         ASSERT(false);
5636                 }
5637         }
5638
5639         Vector4s PixelRoutine::fetchRegisterS(Registers &r, const Src &src)
5640         {
5641                 Vector4s *reg;
5642                 int i = src.index;
5643
5644                 Vector4s c;
5645
5646                 if(src.type == Shader::PARAMETER_CONST)
5647                 {
5648                         c.x = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][0]));
5649                         c.y = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][1]));
5650                         c.z = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][2]));
5651                         c.w = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][3]));
5652                 }
5653
5654                 switch(src.type)
5655                 {
5656                 case Shader::PARAMETER_TEMP:          reg = &r.rs[i]; break;
5657                 case Shader::PARAMETER_INPUT:         reg = &r.vs[i]; break;
5658                 case Shader::PARAMETER_CONST:         reg = &c;       break;
5659                 case Shader::PARAMETER_TEXTURE:       reg = &r.ts[i]; break;
5660                 case Shader::PARAMETER_VOID:          return r.rs[0]; // Dummy
5661                 case Shader::PARAMETER_FLOAT4LITERAL: return r.rs[0]; // Dummy
5662                 default:
5663                         ASSERT(false);
5664                 }
5665
5666                 const Short4 &x = (*reg)[(src.swizzle >> 0) & 0x3];
5667                 const Short4 &y = (*reg)[(src.swizzle >> 2) & 0x3];
5668                 const Short4 &z = (*reg)[(src.swizzle >> 4) & 0x3];
5669                 const Short4 &w = (*reg)[(src.swizzle >> 6) & 0x3];
5670
5671                 Vector4s mod;
5672
5673                 switch(src.modifier)
5674                 {
5675                 case Shader::MODIFIER_NONE:
5676                         mod.x = x;
5677                         mod.y = y;
5678                         mod.z = z;
5679                         mod.w = w;
5680                         break;
5681                 case Shader::MODIFIER_BIAS:
5682                         mod.x = SubSat(x, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5683                         mod.y = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5684                         mod.z = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5685                         mod.w = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5686                         break;
5687                 case Shader::MODIFIER_BIAS_NEGATE:
5688                         mod.x = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), x);
5689                         mod.y = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
5690                         mod.z = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
5691                         mod.w = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), w);
5692                         break;
5693                 case Shader::MODIFIER_COMPLEMENT:
5694                         mod.x = SubSat(Short4(0x1000), x);
5695                         mod.y = SubSat(Short4(0x1000), y);
5696                         mod.z = SubSat(Short4(0x1000), z);
5697                         mod.w = SubSat(Short4(0x1000), w);
5698                         break;
5699                 case Shader::MODIFIER_NEGATE:
5700                         mod.x = -x;
5701                         mod.y = -y;
5702                         mod.z = -z;
5703                         mod.w = -w;
5704                         break;
5705                 case Shader::MODIFIER_X2:
5706                         mod.x = AddSat(x, x);
5707                         mod.y = AddSat(y, y);
5708                         mod.z = AddSat(z, z);
5709                         mod.w = AddSat(w, w);
5710                         break;
5711                 case Shader::MODIFIER_X2_NEGATE:
5712                         mod.x = -AddSat(x, x);
5713                         mod.y = -AddSat(y, y);
5714                         mod.z = -AddSat(z, z);
5715                         mod.w = -AddSat(w, w);
5716                         break;
5717                 case Shader::MODIFIER_SIGN:
5718                         mod.x = SubSat(x, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5719                         mod.y = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5720                         mod.z = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5721                         mod.w = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
5722                         mod.x = AddSat(mod.x, mod.x);
5723                         mod.y = AddSat(mod.y, mod.y);
5724                         mod.z = AddSat(mod.z, mod.z);
5725                         mod.w = AddSat(mod.w, mod.w);
5726                         break;
5727                 case Shader::MODIFIER_SIGN_NEGATE:
5728                         mod.x = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), x);
5729                         mod.y = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
5730                         mod.z = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
5731                         mod.w = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), w);
5732                         mod.x = AddSat(mod.x, mod.x);
5733                         mod.y = AddSat(mod.y, mod.y);
5734                         mod.z = AddSat(mod.z, mod.z);
5735                         mod.w = AddSat(mod.w, mod.w);
5736                         break;
5737                 case Shader::MODIFIER_DZ:
5738                         mod.x = x;
5739                         mod.y = y;
5740                         mod.z = z;
5741                         mod.w = w;
5742                         // Projection performed by texture sampler
5743                         break;
5744                 case Shader::MODIFIER_DW:
5745                         mod.x = x;
5746                         mod.y = y;
5747                         mod.z = z;
5748                         mod.w = w;
5749                         // Projection performed by texture sampler
5750                         break;
5751                 default:
5752                         ASSERT(false);
5753                 }
5754
5755                 if(src.type == Shader::PARAMETER_CONST && (src.modifier == Shader::MODIFIER_X2 || src.modifier == Shader::MODIFIER_X2_NEGATE))
5756                 {
5757                         mod.x = Min(mod.x, Short4(0x1000)); mod.x = Max(mod.x, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
5758                         mod.y = Min(mod.y, Short4(0x1000)); mod.y = Max(mod.y, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
5759                         mod.z = Min(mod.z, Short4(0x1000)); mod.z = Max(mod.z, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
5760                         mod.w = Min(mod.w, Short4(0x1000)); mod.w = Max(mod.w, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
5761                 }
5762
5763                 return mod;
5764         }
5765
5766         Vector4f PixelRoutine::fetchRegisterF(Registers &r, const Src &src, int offset)
5767         {
5768                 Vector4f reg;
5769                 int i = src.index + offset;
5770
5771                 switch(src.type)
5772                 {
5773                 case Shader::PARAMETER_TEMP:
5774                         if(src.rel.type == Shader::PARAMETER_VOID)
5775                         {
5776                                 reg = r.rf[i];
5777                         }
5778                         else
5779                         {
5780                                 Int a = relativeAddress(r, src);
5781
5782                                 reg = r.rf[i + a];
5783                         }
5784                         break;
5785                 case Shader::PARAMETER_INPUT:
5786                         {
5787                                 if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
5788                                 {
5789                                         reg = r.vf[i];
5790                                 }
5791                                 else if(src.rel.type == Shader::PARAMETER_LOOP)
5792                                 {
5793                                         Int aL = r.aL[r.loopDepth];
5794
5795                                         reg = r.vf[i + aL];
5796                                 }
5797                                 else
5798                                 {
5799                                         Int a = relativeAddress(r, src);
5800
5801                                         reg = r.vf[i + a];
5802                                 }
5803                         }
5804                         break;
5805                 case Shader::PARAMETER_CONST:
5806                         reg = readConstant(r, src, offset);
5807                         break;
5808                 case Shader::PARAMETER_TEXTURE:
5809                         reg = r.vf[2 + i];
5810                         break;
5811                 case Shader::PARAMETER_MISCTYPE:
5812                         if(src.index == 0)                              reg = r.vPos;
5813                         if(src.index == 1)                              reg = r.vFace;
5814                         break;
5815                 case Shader::PARAMETER_SAMPLER:
5816                         if(src.rel.type == Shader::PARAMETER_VOID)
5817                         {
5818                                 reg.x = As<Float4>(Int4(i));
5819                         }
5820                         else if(src.rel.type == Shader::PARAMETER_TEMP)
5821                         {
5822                                 reg.x = As<Float4>(Int4(i) + RoundInt(r.rf[src.rel.index].x));
5823                         }
5824                         return reg;
5825                 case Shader::PARAMETER_PREDICATE:       return reg;   // Dummy
5826                 case Shader::PARAMETER_VOID:            return reg;   // Dummy
5827                 case Shader::PARAMETER_FLOAT4LITERAL:
5828                         reg.x = Float4(src.value[0]);
5829                         reg.y = Float4(src.value[1]);
5830                         reg.z = Float4(src.value[2]);
5831                         reg.w = Float4(src.value[3]);
5832                         break;
5833                 case Shader::PARAMETER_CONSTINT:        return reg;   // Dummy
5834                 case Shader::PARAMETER_CONSTBOOL:       return reg;   // Dummy
5835                 case Shader::PARAMETER_LOOP:            return reg;   // Dummy
5836                 case Shader::PARAMETER_COLOROUT:
5837                         reg = r.oC[i];
5838                         break;
5839                 case Shader::PARAMETER_DEPTHOUT:
5840                         reg.x = r.oDepth;
5841                         break;
5842                 default:
5843                         ASSERT(false);
5844                 }
5845
5846                 const Float4 &x = reg[(src.swizzle >> 0) & 0x3];
5847                 const Float4 &y = reg[(src.swizzle >> 2) & 0x3];
5848                 const Float4 &z = reg[(src.swizzle >> 4) & 0x3];
5849                 const Float4 &w = reg[(src.swizzle >> 6) & 0x3];
5850
5851                 Vector4f mod;
5852
5853                 switch(src.modifier)
5854                 {
5855                 case Shader::MODIFIER_NONE:
5856                         mod.x = x;
5857                         mod.y = y;
5858                         mod.z = z;
5859                         mod.w = w;
5860                         break;
5861                 case Shader::MODIFIER_NEGATE:
5862                         mod.x = -x;
5863                         mod.y = -y;
5864                         mod.z = -z;
5865                         mod.w = -w;
5866                         break;
5867                 case Shader::MODIFIER_ABS:
5868                         mod.x = Abs(x);
5869                         mod.y = Abs(y);
5870                         mod.z = Abs(z);
5871                         mod.w = Abs(w);
5872                         break;
5873                 case Shader::MODIFIER_ABS_NEGATE:
5874                         mod.x = -Abs(x);
5875                         mod.y = -Abs(y);
5876                         mod.z = -Abs(z);
5877                         mod.w = -Abs(w);
5878                         break;
5879                 case Shader::MODIFIER_NOT:
5880                         mod.x = As<Float4>(As<Int4>(x) ^ Int4(0xFFFFFFFF));
5881                         mod.y = As<Float4>(As<Int4>(y) ^ Int4(0xFFFFFFFF));
5882                         mod.z = As<Float4>(As<Int4>(z) ^ Int4(0xFFFFFFFF));
5883                         mod.w = As<Float4>(As<Int4>(w) ^ Int4(0xFFFFFFFF));
5884                         break;
5885                 default:
5886                         ASSERT(false);
5887                 }
5888
5889                 return mod;
5890         }
5891
5892         Vector4f PixelRoutine::readConstant(Registers &r, const Src &src, int offset)
5893         {
5894                 Vector4f c;
5895
5896                 int i = src.index + offset;
5897
5898                 if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
5899                 {
5900                         c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[i]));
5901
5902                         c.x = c.x.xxxx;
5903                         c.y = c.y.yyyy;
5904                         c.z = c.z.zzzz;
5905                         c.w = c.w.wwww;
5906
5907                         if(localShaderConstants)   // Constant may be known at compile time
5908                         {
5909                                 for(size_t j = 0; j < shader->getLength(); j++)
5910                                 {
5911                                         const Shader::Instruction &instruction = *shader->getInstruction(j);
5912
5913                                         if(instruction.opcode == Shader::OPCODE_DEF)
5914                                         {
5915                                                 if(instruction.dst.index == i)
5916                                                 {
5917                                                         c.x = Float4(instruction.src[0].value[0]);
5918                                                         c.y = Float4(instruction.src[0].value[1]);
5919                                                         c.z = Float4(instruction.src[0].value[2]);
5920                                                         c.w = Float4(instruction.src[0].value[3]);
5921
5922                                                         break;
5923                                                 }
5924                                         }
5925                                 }
5926                         }
5927                 }
5928                 else if(src.rel.type == Shader::PARAMETER_LOOP)
5929                 {
5930                         Int loopCounter = r.aL[r.loopDepth];
5931
5932                         c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[i]) + loopCounter * 16);
5933
5934                         c.x = c.x.xxxx;
5935                         c.y = c.y.yyyy;
5936                         c.z = c.z.zzzz;
5937                         c.w = c.w.wwww;
5938                 }
5939                 else
5940                 {
5941                         Int a = relativeAddress(r, src);
5942
5943                         c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[i]) + a * 16);
5944
5945                         c.x = c.x.xxxx;
5946                         c.y = c.y.yyyy;
5947                         c.z = c.z.zzzz;
5948                         c.w = c.w.wwww;
5949                 }
5950
5951                 return c;
5952         }
5953
5954         Int PixelRoutine::relativeAddress(Registers &r, const Shader::Parameter &var)
5955         {
5956                 ASSERT(var.rel.deterministic);
5957
5958                 if(var.rel.type == Shader::PARAMETER_TEMP)
5959                 {
5960                         return RoundInt(Extract(r.rf[var.rel.index].x, 0)) * var.rel.scale;
5961                 }
5962                 else if(var.rel.type == Shader::PARAMETER_INPUT)
5963                 {
5964                         return RoundInt(Extract(r.vf[var.rel.index].x, 0)) * var.rel.scale;
5965                 }
5966                 else if(var.rel.type == Shader::PARAMETER_OUTPUT)
5967                 {
5968                         return RoundInt(Extract(r.oC[var.rel.index].x, 0)) * var.rel.scale;
5969                 }
5970                 else if(var.rel.type == Shader::PARAMETER_CONST)
5971                 {
5972                         RValue<Float4> c = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[var.rel.index]));
5973
5974                         return RoundInt(Extract(c, 0)) * var.rel.scale;
5975                 }
5976                 else ASSERT(false);
5977
5978                 return 0;
5979         }
5980
5981         Int4 PixelRoutine::enableMask(Registers &r, const Shader::Instruction *instruction)
5982         {
5983                 Int4 enable = instruction->analysisBranch ? Int4(r.enableStack[r.enableIndex]) : Int4(0xFFFFFFFF);
5984
5985                 if(!whileTest)
5986                 {
5987                         if(shader->containsBreakInstruction() && instruction->analysisBreak)
5988                         {
5989                                 enable &= r.enableBreak;
5990                         }
5991
5992                         if(shader->containsContinueInstruction() && instruction->analysisContinue)
5993                         {
5994                                 enable &= r.enableContinue;
5995                         }
5996
5997                         if(shader->containsLeaveInstruction() && instruction->analysisLeave)
5998                         {
5999                                 enable &= r.enableLeave;
6000                         }
6001                 }
6002
6003                 return enable;
6004         }
6005
6006         bool PixelRoutine::colorUsed()
6007         {
6008                 return state.colorWriteMask || state.alphaTestActive() || state.shaderContainsKill;
6009         }
6010
6011         unsigned short PixelRoutine::shaderVersion() const
6012         {
6013                 return shader ? shader->getVersion() : 0x0000;
6014         }
6015
6016         bool PixelRoutine::interpolateZ() const
6017         {
6018                 return state.depthTestActive || state.pixelFogActive() || (shader && shader->vPosDeclared && fullPixelPositionRegister);
6019         }
6020
6021         bool PixelRoutine::interpolateW() const
6022         {
6023                 return state.perspective || (shader && shader->vPosDeclared && fullPixelPositionRegister);
6024         }
6025 }