Add SwiftShader source to repo
Oct 6 code drop from Transgaming
Review URL: https://chromereviews.googleplex.com/3846015
diff --git a/src/Shader/Constants.cpp b/src/Shader/Constants.cpp
new file mode 100644
index 0000000..d111e5e
--- /dev/null
+++ b/src/Shader/Constants.cpp
@@ -0,0 +1,345 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "Constants.hpp"
+
+#include "Math.hpp"
+#include "Half.hpp"
+
+#include <memory.h>
+
+namespace sw
+{
+ Constants::Constants()
+ {
+ for(int i = 0; i < 256; i++)
+ {
+ sRGBtoLinear8[i] = (unsigned short)(sw::sRGBtoLinear((float)i / 0xFF) * 0x1000 + 0.5f);
+ }
+
+ static const unsigned int transposeBit0[16] =
+ {
+ 0x00000000,
+ 0x00000001,
+ 0x00000010,
+ 0x00000011,
+ 0x00000100,
+ 0x00000101,
+ 0x00000110,
+ 0x00000111,
+ 0x00001000,
+ 0x00001001,
+ 0x00001010,
+ 0x00001011,
+ 0x00001100,
+ 0x00001101,
+ 0x00001110,
+ 0x00001111
+ };
+
+ static const unsigned int transposeBit1[16] =
+ {
+ 0x00000000,
+ 0x00000002,
+ 0x00000020,
+ 0x00000022,
+ 0x00000200,
+ 0x00000202,
+ 0x00000220,
+ 0x00000222,
+ 0x00002000,
+ 0x00002002,
+ 0x00002020,
+ 0x00002022,
+ 0x00002200,
+ 0x00002202,
+ 0x00002220,
+ 0x00002222
+ };
+
+ static const unsigned int transposeBit2[16] =
+ {
+ 0x00000000,
+ 0x00000004,
+ 0x00000040,
+ 0x00000044,
+ 0x00000400,
+ 0x00000404,
+ 0x00000440,
+ 0x00000444,
+ 0x00004000,
+ 0x00004004,
+ 0x00004040,
+ 0x00004044,
+ 0x00004400,
+ 0x00004404,
+ 0x00004440,
+ 0x00004444
+ };
+
+ memcpy(&this->transposeBit0, transposeBit0, sizeof(transposeBit0));
+ memcpy(&this->transposeBit1, transposeBit1, sizeof(transposeBit1));
+ memcpy(&this->transposeBit2, transposeBit2, sizeof(transposeBit2));
+
+ static const ushort4 cWeight[17] =
+ {
+ {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF}, // 0xFFFF / 1 = 0xFFFF
+ {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF}, // 0xFFFF / 1 = 0xFFFF
+ {0x8000, 0x8000, 0x8000, 0x8000}, // 0xFFFF / 2 = 0x8000
+ {0x5555, 0x5555, 0x5555, 0x5555}, // 0xFFFF / 3 = 0x5555
+ {0x4000, 0x4000, 0x4000, 0x4000}, // 0xFFFF / 4 = 0x4000
+ {0x3333, 0x3333, 0x3333, 0x3333}, // 0xFFFF / 5 = 0x3333
+ {0x2AAA, 0x2AAA, 0x2AAA, 0x2AAA}, // 0xFFFF / 6 = 0x2AAA
+ {0x2492, 0x2492, 0x2492, 0x2492}, // 0xFFFF / 7 = 0x2492
+ {0x2000, 0x2000, 0x2000, 0x2000}, // 0xFFFF / 8 = 0x2000
+ {0x1C71, 0x1C71, 0x1C71, 0x1C71}, // 0xFFFF / 9 = 0x1C71
+ {0x1999, 0x1999, 0x1999, 0x1999}, // 0xFFFF / 10 = 0x1999
+ {0x1745, 0x1745, 0x1745, 0x1745}, // 0xFFFF / 11 = 0x1745
+ {0x1555, 0x1555, 0x1555, 0x1555}, // 0xFFFF / 12 = 0x1555
+ {0x13B1, 0x13B1, 0x13B1, 0x13B1}, // 0xFFFF / 13 = 0x13B1
+ {0x1249, 0x1249, 0x1249, 0x1249}, // 0xFFFF / 14 = 0x1249
+ {0x1111, 0x1111, 0x1111, 0x1111}, // 0xFFFF / 15 = 0x1111
+ {0x1000, 0x1000, 0x1000, 0x1000}, // 0xFFFF / 16 = 0x1000
+ };
+
+ static const float4 uvWeight[17] =
+ {
+ {1.0f / 1.0f, 1.0f / 1.0f, 1.0f / 1.0f, 1.0f / 1.0f},
+ {1.0f / 1.0f, 1.0f / 1.0f, 1.0f / 1.0f, 1.0f / 1.0f},
+ {1.0f / 2.0f, 1.0f / 2.0f, 1.0f / 2.0f, 1.0f / 2.0f},
+ {1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f},
+ {1.0f / 4.0f, 1.0f / 4.0f, 1.0f / 4.0f, 1.0f / 4.0f},
+ {1.0f / 5.0f, 1.0f / 5.0f, 1.0f / 5.0f, 1.0f / 5.0f},
+ {1.0f / 6.0f, 1.0f / 6.0f, 1.0f / 6.0f, 1.0f / 6.0f},
+ {1.0f / 7.0f, 1.0f / 7.0f, 1.0f / 7.0f, 1.0f / 7.0f},
+ {1.0f / 8.0f, 1.0f / 8.0f, 1.0f / 8.0f, 1.0f / 8.0f},
+ {1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f},
+ {1.0f / 10.0f, 1.0f / 10.0f, 1.0f / 10.0f, 1.0f / 10.0f},
+ {1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f},
+ {1.0f / 12.0f, 1.0f / 12.0f, 1.0f / 12.0f, 1.0f / 12.0f},
+ {1.0f / 13.0f, 1.0f / 13.0f, 1.0f / 13.0f, 1.0f / 13.0f},
+ {1.0f / 14.0f, 1.0f / 14.0f, 1.0f / 14.0f, 1.0f / 14.0f},
+ {1.0f / 15.0f, 1.0f / 15.0f, 1.0f / 15.0f, 1.0f / 15.0f},
+ {1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f},
+ };
+
+ static const float4 uvStart[17] =
+ {
+ {-0.0f / 2.0f, -0.0f / 2.0f, -0.0f / 2.0f, -0.0f / 2.0f},
+ {-0.0f / 2.0f, -0.0f / 2.0f, -0.0f / 2.0f, -0.0f / 2.0f},
+ {-1.0f / 4.0f, -1.0f / 4.0f, -1.0f / 4.0f, -1.0f / 4.0f},
+ {-2.0f / 6.0f, -2.0f / 6.0f, -2.0f / 6.0f, -2.0f / 6.0f},
+ {-3.0f / 8.0f, -3.0f / 8.0f, -3.0f / 8.0f, -3.0f / 8.0f},
+ {-4.0f / 10.0f, -4.0f / 10.0f, -4.0f / 10.0f, -4.0f / 10.0f},
+ {-5.0f / 12.0f, -5.0f / 12.0f, -5.0f / 12.0f, -5.0f / 12.0f},
+ {-6.0f / 14.0f, -6.0f / 14.0f, -6.0f / 14.0f, -6.0f / 14.0f},
+ {-7.0f / 16.0f, -7.0f / 16.0f, -7.0f / 16.0f, -7.0f / 16.0f},
+ {-8.0f / 18.0f, -8.0f / 18.0f, -8.0f / 18.0f, -8.0f / 18.0f},
+ {-9.0f / 20.0f, -9.0f / 20.0f, -9.0f / 20.0f, -9.0f / 20.0f},
+ {-10.0f / 22.0f, -10.0f / 22.0f, -10.0f / 22.0f, -10.0f / 22.0f},
+ {-11.0f / 24.0f, -11.0f / 24.0f, -11.0f / 24.0f, -11.0f / 24.0f},
+ {-12.0f / 26.0f, -12.0f / 26.0f, -12.0f / 26.0f, -12.0f / 26.0f},
+ {-13.0f / 28.0f, -13.0f / 28.0f, -13.0f / 28.0f, -13.0f / 28.0f},
+ {-14.0f / 30.0f, -14.0f / 30.0f, -14.0f / 30.0f, -14.0f / 30.0f},
+ {-15.0f / 32.0f, -15.0f / 32.0f, -15.0f / 32.0f, -15.0f / 32.0f},
+ };
+
+ memcpy(&this->cWeight, cWeight, sizeof(cWeight));
+ memcpy(&this->uvWeight, uvWeight, sizeof(uvWeight));
+ memcpy(&this->uvStart, uvStart, sizeof(uvStart));
+
+ static const unsigned int occlusionCount[16] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+
+ memcpy(&this->occlusionCount, &occlusionCount, sizeof(occlusionCount));
+
+ for(int i = 0; i < 16; i++)
+ {
+ maskB4Q[i][0] = -(i >> 0 & 1);
+ maskB4Q[i][1] = -(i >> 1 & 1);
+ maskB4Q[i][2] = -(i >> 2 & 1);
+ maskB4Q[i][3] = -(i >> 3 & 1);
+ maskB4Q[i][4] = -(i >> 0 & 1);
+ maskB4Q[i][5] = -(i >> 1 & 1);
+ maskB4Q[i][6] = -(i >> 2 & 1);
+ maskB4Q[i][7] = -(i >> 3 & 1);
+
+ invMaskB4Q[i][0] = ~-(i >> 0 & 1);
+ invMaskB4Q[i][1] = ~-(i >> 1 & 1);
+ invMaskB4Q[i][2] = ~-(i >> 2 & 1);
+ invMaskB4Q[i][3] = ~-(i >> 3 & 1);
+ invMaskB4Q[i][4] = ~-(i >> 0 & 1);
+ invMaskB4Q[i][5] = ~-(i >> 1 & 1);
+ invMaskB4Q[i][6] = ~-(i >> 2 & 1);
+ invMaskB4Q[i][7] = ~-(i >> 3 & 1);
+
+ maskW4Q[i][0] = -(i >> 0 & 1);
+ maskW4Q[i][1] = -(i >> 1 & 1);
+ maskW4Q[i][2] = -(i >> 2 & 1);
+ maskW4Q[i][3] = -(i >> 3 & 1);
+
+ invMaskW4Q[i][0] = ~-(i >> 0 & 1);
+ invMaskW4Q[i][1] = ~-(i >> 1 & 1);
+ invMaskW4Q[i][2] = ~-(i >> 2 & 1);
+ invMaskW4Q[i][3] = ~-(i >> 3 & 1);
+
+ maskD4X[i][0] = -(i >> 0 & 1);
+ maskD4X[i][1] = -(i >> 1 & 1);
+ maskD4X[i][2] = -(i >> 2 & 1);
+ maskD4X[i][3] = -(i >> 3 & 1);
+
+ invMaskD4X[i][0] = ~-(i >> 0 & 1);
+ invMaskD4X[i][1] = ~-(i >> 1 & 1);
+ invMaskD4X[i][2] = ~-(i >> 2 & 1);
+ invMaskD4X[i][3] = ~-(i >> 3 & 1);
+
+ maskQ0Q[i] = -(i >> 0 & 1);
+ maskQ1Q[i] = -(i >> 1 & 1);
+ maskQ2Q[i] = -(i >> 2 & 1);
+ maskQ3Q[i] = -(i >> 3 & 1);
+
+ invMaskQ0Q[i] = ~-(i >> 0 & 1);
+ invMaskQ1Q[i] = ~-(i >> 1 & 1);
+ invMaskQ2Q[i] = ~-(i >> 2 & 1);
+ invMaskQ3Q[i] = ~-(i >> 3 & 1);
+
+ maskX0X[i][0] = maskX0X[i][1] = maskX0X[i][2] = maskX0X[i][3] = -(i >> 0 & 1);
+ maskX1X[i][0] = maskX1X[i][1] = maskX1X[i][2] = maskX1X[i][3] = -(i >> 1 & 1);
+ maskX2X[i][0] = maskX2X[i][1] = maskX2X[i][2] = maskX2X[i][3] = -(i >> 2 & 1);
+ maskX3X[i][0] = maskX3X[i][1] = maskX3X[i][2] = maskX3X[i][3] = -(i >> 3 & 1);
+
+ invMaskX0X[i][0] = invMaskX0X[i][1] = invMaskX0X[i][2] = invMaskX0X[i][3] = ~-(i >> 0 & 1);
+ invMaskX1X[i][0] = invMaskX1X[i][1] = invMaskX1X[i][2] = invMaskX1X[i][3] = ~-(i >> 1 & 1);
+ invMaskX2X[i][0] = invMaskX2X[i][1] = invMaskX2X[i][2] = invMaskX2X[i][3] = ~-(i >> 2 & 1);
+ invMaskX3X[i][0] = invMaskX3X[i][1] = invMaskX3X[i][2] = invMaskX3X[i][3] = ~-(i >> 3 & 1);
+
+ maskD01Q[i][0] = -(i >> 0 & 1);
+ maskD01Q[i][1] = -(i >> 1 & 1);
+ maskD23Q[i][0] = -(i >> 2 & 1);
+ maskD23Q[i][1] = -(i >> 3 & 1);
+
+ invMaskD01Q[i][0] = ~-(i >> 0 & 1);
+ invMaskD01Q[i][1] = ~-(i >> 1 & 1);
+ invMaskD23Q[i][0] = ~-(i >> 2 & 1);
+ invMaskD23Q[i][1] = ~-(i >> 3 & 1);
+
+ maskQ01X[i][0] = -(i >> 0 & 1);
+ maskQ01X[i][1] = -(i >> 1 & 1);
+ maskQ23X[i][0] = -(i >> 2 & 1);
+ maskQ23X[i][1] = -(i >> 3 & 1);
+
+ invMaskQ01X[i][0] = ~-(i >> 0 & 1);
+ invMaskQ01X[i][1] = ~-(i >> 1 & 1);
+ invMaskQ23X[i][0] = ~-(i >> 2 & 1);
+ invMaskQ23X[i][1] = ~-(i >> 3 & 1);
+ }
+
+ for(int i = 0; i < 4; i++)
+ {
+ maskW01Q[i][0] = -(i >> 0 & 1);
+ maskW01Q[i][1] = -(i >> 1 & 1);
+ maskW01Q[i][2] = -(i >> 0 & 1);
+ maskW01Q[i][3] = -(i >> 1 & 1);
+
+ invMaskW01Q[i][0] = ~-(i >> 0 & 1);
+ invMaskW01Q[i][1] = ~-(i >> 1 & 1);
+ invMaskW01Q[i][2] = ~-(i >> 0 & 1);
+ invMaskW01Q[i][3] = ~-(i >> 1 & 1);
+
+ maskD01X[i][0] = -(i >> 0 & 1);
+ maskD01X[i][1] = -(i >> 1 & 1);
+ maskD01X[i][2] = -(i >> 0 & 1);
+ maskD01X[i][3] = -(i >> 1 & 1);
+
+ invMaskD01X[i][0] = ~-(i >> 0 & 1);
+ invMaskD01X[i][1] = ~-(i >> 1 & 1);
+ invMaskD01X[i][2] = ~-(i >> 0 & 1);
+ invMaskD01X[i][3] = ~-(i >> 1 & 1);
+ }
+
+ for(int i = 0; i < 0x1000; i++)
+ {
+ linToSRGB12_16[i] = (unsigned short)(clamp(sw::linearToSRGB((float)i / 0x0FFF) * 0xFFFF + 0.5f, 0.0f, (float)0xFFFF));
+ sRGBtoLin12_16[i] = (unsigned short)(clamp(sw::sRGBtoLinear((float)i / 0x0FFF) * 0xFFFF + 0.5f, 0.0f, (float)0xFFFF));
+ }
+
+ for(int q = 0; q < 4; q++)
+ {
+ for(int c = 0; c < 16; c++)
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ const float X[4] = {+0.3125f, -0.3125f, -0.1250f, +0.1250f};
+ const float Y[4] = {+0.1250f, -0.1250f, +0.3125f, -0.3125f};
+
+ sampleX[q][c][i] = c & (1 << i) ? X[q] : 0.0f;
+ sampleY[q][c][i] = c & (1 << i) ? Y[q] : 0.0f;
+ weight[c][i] = c & (1 << i) ? 1.0f : 0.0f;
+ }
+ }
+ }
+
+ const int Xf[4] = {-5, +5, +2, -2}; // Fragment offsets
+ const int Yf[4] = {-2, +2, -5, +5}; // Fragment offsets
+
+ memcpy(&this->Xf, &Xf, sizeof(Xf));
+ memcpy(&this->Yf, &Yf, sizeof(Yf));
+
+ static const float4 X[4] = {{-0.3125f, -0.3125f, -0.3125f, -0.3125f},
+ {+0.3125f, +0.3125f, +0.3125f, +0.3125f},
+ {+0.1250f, +0.1250f, +0.1250f, +0.1250f},
+ {-0.1250f, -0.1250f, -0.1250f, -0.1250f}};
+
+ static const float4 Y[4] = {{-0.1250f, -0.1250f, -0.1250f, -0.1250f},
+ {+0.1250f, +0.1250f, +0.1250f, +0.1250f},
+ {-0.3125f, -0.3125f, -0.3125f, -0.3125f},
+ {+0.3125f, +0.3125f, +0.3125f, +0.3125f}};
+
+ memcpy(&this->X, &X, sizeof(X));
+ memcpy(&this->Y, &Y, sizeof(Y));
+
+ const dword maxX[16] = {0x00000000, 0x00000001, 0x00000100, 0x00000101, 0x00010000, 0x00010001, 0x00010100, 0x00010101, 0x01000000, 0x01000001, 0x01000100, 0x01000101, 0x01010000, 0x01010001, 0x01010100, 0x01010101};
+ const dword maxY[16] = {0x00000000, 0x00000002, 0x00000200, 0x00000202, 0x00020000, 0x00020002, 0x00020200, 0x00020202, 0x02000000, 0x02000002, 0x02000200, 0x02000202, 0x02020000, 0x02020002, 0x02020200, 0x02020202};
+ const dword maxZ[16] = {0x00000000, 0x00000004, 0x00000400, 0x00000404, 0x00040000, 0x00040004, 0x00040400, 0x00040404, 0x04000000, 0x04000004, 0x04000400, 0x04000404, 0x04040000, 0x04040004, 0x04040400, 0x04040404};
+ const dword minX[16] = {0x00000000, 0x00000008, 0x00000800, 0x00000808, 0x00080000, 0x00080008, 0x00080800, 0x00080808, 0x08000000, 0x08000008, 0x08000800, 0x08000808, 0x08080000, 0x08080008, 0x08080800, 0x08080808};
+ const dword minY[16] = {0x00000000, 0x00000010, 0x00001000, 0x00001010, 0x00100000, 0x00100010, 0x00101000, 0x00101010, 0x10000000, 0x10000010, 0x10001000, 0x10001010, 0x10100000, 0x10100010, 0x10101000, 0x10101010};
+ const dword minZ[16] = {0x00000000, 0x00000020, 0x00002000, 0x00002020, 0x00200000, 0x00200020, 0x00202000, 0x00202020, 0x20000000, 0x20000020, 0x20002000, 0x20002020, 0x20200000, 0x20200020, 0x20202000, 0x20202020};
+ const dword fini[16] = {0x00000000, 0x00000080, 0x00008000, 0x00008080, 0x00800000, 0x00800080, 0x00808000, 0x00808080, 0x80000000, 0x80000080, 0x80008000, 0x80008080, 0x80800000, 0x80800080, 0x80808000, 0x80808080};
+
+ memcpy(&this->maxX, &maxX, sizeof(maxX));
+ memcpy(&this->maxY, &maxY, sizeof(maxY));
+ memcpy(&this->maxZ, &maxZ, sizeof(maxZ));
+ memcpy(&this->minX, &minX, sizeof(minX));
+ memcpy(&this->minY, &minY, sizeof(minY));
+ memcpy(&this->minZ, &minZ, sizeof(minZ));
+ memcpy(&this->fini, &fini, sizeof(fini));
+
+ static const dword4 maxPos = {0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFE};
+
+ memcpy(&this->maxPos, &maxPos, sizeof(maxPos));
+
+ static const float4 unscaleByte = {1.0f / 0xFF, 1.0f / 0xFF, 1.0f / 0xFF, 1.0f / 0xFF};
+ static const float4 unscaleSByte = {1.0f / 0x7F, 1.0f / 0x7F, 1.0f / 0x7F, 1.0f / 0x7F};
+ static const float4 unscaleShort = {1.0f / 0x7FFF, 1.0f / 0x7FFF, 1.0f / 0x7FFF, 1.0f / 0x7FFF};
+ static const float4 unscaleUShort = {1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF};
+ static const float4 unscaleFixed = {1.0f / 0x00010000, 1.0f / 0x00010000, 1.0f / 0x00010000, 1.0f / 0x00010000};
+
+ memcpy(&this->unscaleByte, &unscaleByte, sizeof(unscaleByte));
+ memcpy(&this->unscaleSByte, &unscaleSByte, sizeof(unscaleSByte));
+ memcpy(&this->unscaleShort, &unscaleShort, sizeof(unscaleShort));
+ memcpy(&this->unscaleUShort, &unscaleUShort, sizeof(unscaleUShort));
+ memcpy(&this->unscaleFixed, &unscaleFixed, sizeof(unscaleFixed));
+
+ for(int i = 0; i <= 0xFFFF; i++)
+ {
+ half2float[i] = (float)reinterpret_cast<half&>(i);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Shader/Constants.hpp b/src/Shader/Constants.hpp
new file mode 100644
index 0000000..d803ed3
--- /dev/null
+++ b/src/Shader/Constants.hpp
@@ -0,0 +1,102 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "Types.hpp"
+
+namespace sw
+{
+ struct Constants
+ {
+ Constants();
+
+ unsigned short sRGBtoLinear8[256];
+
+ unsigned int transposeBit0[16];
+ unsigned int transposeBit1[16];
+ unsigned int transposeBit2[16];
+
+ ushort4 cWeight[17];
+ float4 uvWeight[17];
+ float4 uvStart[17];
+
+ unsigned int occlusionCount[16];
+
+ byte8 maskB4Q[16];
+ byte8 invMaskB4Q[16];
+ word4 maskW4Q[16];
+ word4 invMaskW4Q[16];
+ dword4 maskD4X[16];
+ dword4 invMaskD4X[16];
+ qword maskQ0Q[16];
+ qword maskQ1Q[16];
+ qword maskQ2Q[16];
+ qword maskQ3Q[16];
+ qword invMaskQ0Q[16];
+ qword invMaskQ1Q[16];
+ qword invMaskQ2Q[16];
+ qword invMaskQ3Q[16];
+ dword4 maskX0X[16];
+ dword4 maskX1X[16];
+ dword4 maskX2X[16];
+ dword4 maskX3X[16];
+ dword4 invMaskX0X[16];
+ dword4 invMaskX1X[16];
+ dword4 invMaskX2X[16];
+ dword4 invMaskX3X[16];
+ dword2 maskD01Q[16];
+ dword2 maskD23Q[16];
+ dword2 invMaskD01Q[16];
+ dword2 invMaskD23Q[16];
+ qword2 maskQ01X[16];
+ qword2 maskQ23X[16];
+ qword2 invMaskQ01X[16];
+ qword2 invMaskQ23X[16];
+ word4 maskW01Q[4];
+ word4 invMaskW01Q[4];
+ dword4 maskD01X[4];
+ dword4 invMaskD01X[4];
+
+ unsigned short linToSRGB12_16[4096];
+ unsigned short sRGBtoLin12_16[4096];
+
+ // Centroid parameters
+ float4 sampleX[4][16];
+ float4 sampleY[4][16];
+ float4 weight[16];
+
+ // Fragment offsets
+ int Xf[4];
+ int Yf[4];
+
+ float4 X[4];
+ float4 Y[4];
+
+ dword maxX[16];
+ dword maxY[16];
+ dword maxZ[16];
+ dword minX[16];
+ dword minY[16];
+ dword minZ[16];
+ dword fini[16];
+
+ dword4 maxPos;
+
+ float4 unscaleByte;
+ float4 unscaleSByte;
+ float4 unscaleShort;
+ float4 unscaleUShort;
+ float4 unscaleFixed;
+
+ float half2float[65536];
+ };
+
+ static Constants constants;
+}
diff --git a/src/Shader/PixelRoutine.cpp b/src/Shader/PixelRoutine.cpp
new file mode 100644
index 0000000..f1ac5be
--- /dev/null
+++ b/src/Shader/PixelRoutine.cpp
@@ -0,0 +1,5399 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "PixelRoutine.hpp"
+
+#include "Renderer.hpp"
+#include "PixelShader.hpp"
+#include "QuadRasterizer.hpp"
+#include "Surface.hpp"
+#include "Primitive.hpp"
+#include "CPUID.hpp"
+#include "SamplerCore.hpp"
+#include "Constants.hpp"
+#include "Debug.hpp"
+
+#include <assert.h>
+
+extern bool localShaderConstants;
+
+namespace sw
+{
+ extern bool complementaryDepthBuffer;
+ extern bool postBlendSRGB;
+ extern bool exactColorRounding;
+
+ PixelRoutine::PixelRoutine(const PixelProcessor::State &state, const PixelShader *pixelShader) : Rasterizer(state), pixelShader(pixelShader)
+ {
+ perturbate = false;
+ luminance = false;
+ previousScaling = false;
+
+ returns = false;
+ ifDepth = 0;
+ loopRepDepth = 0;
+ breakDepth = 0;
+
+ for(int i = 0; i < 2048; i++)
+ {
+ labelBlock[i] = 0;
+ }
+ }
+
+ PixelRoutine::~PixelRoutine()
+ {
+ for(int i = 0; i < 16; i++)
+ {
+ delete sampler[i];
+ }
+ }
+
+ void PixelRoutine::quad(Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y)
+ {
+ #if PERF_PROFILE
+ Long pipeTime = Ticks();
+ #endif
+
+ for(int i = 0; i < 16; i++)
+ {
+ sampler[i] = new SamplerCore(r.constants, state.sampler[i]);
+ }
+
+ const bool earlyDepthTest = !state.depthOverride && !state.alphaTestActive();
+ const bool integerPipeline = pixelShaderVersion() <= 0x0104;
+
+ Int zMask[4]; // Depth mask
+ Int sMask[4]; // Stencil mask
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ zMask[q] = cMask[q];
+ sMask[q] = cMask[q];
+ }
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ stencilTest(r, sBuffer, q, x, sMask[q], cMask[q]);
+ }
+
+ Float4 f;
+
+ Color4i ¤t = r.ri[0];
+ Color4i &diffuse = r.vi[0];
+ Color4i &specular = r.vi[1];
+
+ Float4 (&z)[4] = r.z;
+ Float4 &rhw = r.rhw;
+ Float4 rhwCentroid;
+
+ Float4 xxxx = Float4(Float(x)) + *Pointer<Float4>(r.primitive + OFFSET(Primitive,xQuad), 16);
+ Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(r.primitive + OFFSET(Primitive,yQuad), 16);
+
+ if(state.depthTestActive || state.pixelFogActive())
+ {
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ Float4 x = xxxx;
+
+ if(state.multiSample > 1)
+ {
+ x -= *Pointer<Float4>(r.constants + OFFSET(Constants,X) + q * sizeof(float4));
+ }
+
+ z[q] = interpolate(x, r.Dz[q], z[q], r.primitive + OFFSET(Primitive,z), false, false);
+ }
+ }
+
+ Bool depthPass = false;
+
+ if(earlyDepthTest)
+ {
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ depthPass = depthPass || depthTest(r, zBuffer, q, x, z[q], sMask[q], zMask[q], cMask[q]);
+ }
+ }
+
+ If(depthPass || Bool(!earlyDepthTest))
+ {
+ #if PERF_PROFILE
+ Long interpTime = Ticks();
+ #endif
+
+ // Centroid locations
+ Float4 XXXX = Float4(0.0f);
+ Float4 YYYY = Float4(0.0f);
+
+ if(state.centroid)
+ {
+ Float4 WWWW(1.0e-9f);
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ XXXX += *Pointer<Float4>(r.constants + OFFSET(Constants,sampleX[q]) + 16 * cMask[q]);
+ YYYY += *Pointer<Float4>(r.constants + OFFSET(Constants,sampleY[q]) + 16 * cMask[q]);
+ WWWW += *Pointer<Float4>(r.constants + OFFSET(Constants,weight) + 16 * cMask[q]);
+ }
+
+ WWWW = Rcp_pp(WWWW);
+ XXXX *= WWWW;
+ YYYY *= WWWW;
+
+ XXXX += xxxx;
+ YYYY += yyyy;
+ }
+
+ if(state.perspective)
+ {
+ rhw = reciprocal(interpolate(xxxx, r.Dw, rhw, r.primitive + OFFSET(Primitive,w), false, false));
+
+ if(state.centroid)
+ {
+ rhwCentroid = reciprocal(interpolateCentroid(XXXX, YYYY, rhwCentroid, r.primitive + OFFSET(Primitive,w), false, false));
+ }
+ }
+
+ for(int interpolant = 0; interpolant < 10; interpolant++)
+ {
+ for(int component = 0; component < 4; component++)
+ {
+ Array<Float4> *pv;
+
+ switch(component)
+ {
+ case 0: pv = &r.vx; break;
+ case 1: pv = &r.vy; break;
+ case 2: pv = &r.vz; break;
+ case 3: pv = &r.vw; break;
+ }
+
+ Array<Float4> &v = *pv;
+
+ if(state.interpolant[interpolant].component & (1 << component))
+ {
+ if(!state.interpolant[interpolant].centroid)
+ {
+ v[interpolant] = interpolate(xxxx, r.Dv[interpolant][component], rhw, r.primitive + OFFSET(Primitive,V[interpolant][component]), state.interpolant[interpolant].flat & (1 << component), state.perspective);
+ }
+ else
+ {
+ v[interpolant] = interpolateCentroid(XXXX, YYYY, rhwCentroid, r.primitive + OFFSET(Primitive,V[interpolant][component]), state.interpolant[interpolant].flat & (1 << component), state.perspective);
+ }
+ }
+ }
+
+ Float4 rcp;
+
+ switch(state.interpolant[interpolant].project)
+ {
+ case 0:
+ break;
+ case 1:
+ rcp = reciprocal(Float4(r.vy[interpolant]));
+ r.vx[interpolant] = r.vx[interpolant] * rcp;
+ break;
+ case 2:
+ rcp = reciprocal(Float4(r.vz[interpolant]));
+ r.vx[interpolant] = r.vx[interpolant] * rcp;
+ r.vy[interpolant] = r.vy[interpolant] * rcp;
+ break;
+ case 3:
+ rcp = reciprocal(Float4(r.vw[interpolant]));
+ r.vx[interpolant] = r.vx[interpolant] * rcp;
+ r.vy[interpolant] = r.vy[interpolant] * rcp;
+ r.vz[interpolant] = r.vz[interpolant] * rcp;
+ break;
+ }
+ }
+
+ if(state.fog.component)
+ {
+ f = interpolate(xxxx, r.Df, rhw, r.primitive + OFFSET(Primitive,f), state.fog.flat & 0x01, state.perspective);
+ }
+
+ if(integerPipeline)
+ {
+ if(state.color[0].component & 0x1) diffuse.x = convertFixed12(Float4(r.vx[0])); else diffuse.x = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ if(state.color[0].component & 0x2) diffuse.y = convertFixed12(Float4(r.vy[0])); else diffuse.y = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ if(state.color[0].component & 0x4) diffuse.z = convertFixed12(Float4(r.vz[0])); else diffuse.z = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ if(state.color[0].component & 0x8) diffuse.w = convertFixed12(Float4(r.vw[0])); else diffuse.w = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+
+ if(state.color[1].component & 0x1) specular.x = convertFixed12(Float4(r.vx[1])); else specular.x = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ if(state.color[1].component & 0x2) specular.y = convertFixed12(Float4(r.vy[1])); else specular.y = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ if(state.color[1].component & 0x4) specular.z = convertFixed12(Float4(r.vz[1])); else specular.z = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ if(state.color[1].component & 0x8) specular.w = convertFixed12(Float4(r.vw[1])); else specular.w = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ }
+ else if(pixelShaderVersion() >= 0x0300)
+ {
+ if(pixelShader->vPosDeclared)
+ {
+ r.vPos.x = Float4(Float(x)) + Float4(0, 1, 0, 1);
+ r.vPos.y = Float4(Float(y)) + Float4(0, 0, 1, 1);
+ }
+
+ if(pixelShader->vFaceDeclared)
+ {
+ Float4 area = *Pointer<Float>(r.primitive + OFFSET(Primitive,area));
+
+ r.vFace.x = area;
+ r.vFace.y = area;
+ r.vFace.z = area;
+ r.vFace.w = area;
+ }
+ }
+
+ #if PERF_PROFILE
+ r.cycles[PERF_INTERP] += Ticks() - interpTime;
+ #endif
+
+ Bool alphaPass = true;
+
+ if(colorUsed())
+ {
+ #if PERF_PROFILE
+ Long shaderTime = Ticks();
+ #endif
+
+ if(pixelShader)
+ {
+ // pixelShader->print("PixelShader-%0.16llX.txt", state.shaderHash);
+
+ if(pixelShader->getVersion() <= 0x0104)
+ {
+ ps_1_x(r, cMask);
+ }
+ else
+ {
+ ps_2_x(r, cMask);
+ }
+ }
+ else
+ {
+ current = diffuse;
+ Color4i temp(0x0000, 0x0000, 0x0000, 0x0000);
+
+ for(int stage = 0; stage < 8; stage++)
+ {
+ if(state.textureStage[stage].stageOperation == TextureStage::STAGE_DISABLE)
+ {
+ break;
+ }
+
+ Color4i texture;
+
+ if(state.textureStage[stage].usesTexture)
+ {
+ sampleTexture(r, texture, stage, stage);
+ }
+
+ blendTexture(r, current, temp, texture, stage);
+ }
+
+ specularPixel(current, specular);
+ }
+
+ #if PERF_PROFILE
+ r.cycles[PERF_SHADER] += Ticks() - shaderTime;
+ #endif
+
+ if(integerPipeline)
+ {
+ current.r = Min(current.r, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); current.r = Max(current.r, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ current.g = Min(current.g, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); current.g = Max(current.g, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ current.b = Min(current.b, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); current.b = Max(current.b, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ current.a = Min(current.a, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); current.a = Max(current.a, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+
+ alphaPass = alphaTest(r, cMask, current);
+ }
+ else
+ {
+ clampColor(r.oC);
+
+ alphaPass = alphaTest(r, cMask, r.oC[0]);
+ }
+
+ if((pixelShader && pixelShader->containsTexkill()) || state.alphaTestActive())
+ {
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ zMask[q] &= cMask[q];
+ sMask[q] &= cMask[q];
+ }
+ }
+ }
+
+ If(alphaPass)
+ {
+ if(!earlyDepthTest)
+ {
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ depthPass = depthPass || depthTest(r, zBuffer, q, x, z[q], sMask[q], zMask[q], cMask[q]);
+ }
+ }
+
+ #if PERF_PROFILE
+ Long ropTime = Ticks();
+ #endif
+
+ If(depthPass || Bool(earlyDepthTest))
+ {
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ if(state.multiSampleMask & (1 << q))
+ {
+ writeDepth(r, zBuffer, q, x, z[q], zMask[q]);
+
+ if(state.occlusionEnabled)
+ {
+ r.occlusion += *Pointer<UInt>(r.constants + OFFSET(Constants,occlusionCount) + 4 * (zMask[q] & sMask[q]));
+ }
+ }
+ }
+
+ if(colorUsed())
+ {
+ #if PERF_PROFILE
+ AddAtomic(Pointer<Long>(&profiler.ropOperations), Long(4));
+ #endif
+
+ if(integerPipeline)
+ {
+ rasterOperation(current, r, f, cBuffer[0], x, sMask, zMask, cMask);
+ }
+ else
+ {
+ rasterOperation(r.oC, r, f, cBuffer, x, sMask, zMask, cMask);
+ }
+ }
+ }
+
+ #if PERF_PROFILE
+ r.cycles[PERF_ROP] += Ticks() - ropTime;
+ #endif
+ }
+ }
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ if(state.multiSampleMask & (1 << q))
+ {
+ writeStencil(r, sBuffer, q, x, sMask[q], zMask[q], cMask[q]);
+ }
+ }
+
+ #if PERF_PROFILE
+ r.cycles[PERF_PIPE] += Ticks() - pipeTime;
+ #endif
+ }
+
+ Float4 PixelRoutine::interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
+ {
+ Float4 interpolant = D;
+
+ if(!flat)
+ {
+ interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,A), 16);
+
+ if(perspective)
+ {
+ interpolant *= rhw;
+ }
+ }
+
+ return interpolant;
+ }
+
+ Float4 PixelRoutine::interpolateCentroid(Float4 &x, Float4 &y, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
+ {
+ Float4 interpolant = *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,C), 16);
+
+ if(!flat)
+ {
+ interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,A), 16) +
+ y * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,B), 16);
+
+ if(perspective)
+ {
+ interpolant *= rhw;
+ }
+ }
+
+ return interpolant;
+ }
+
+ void PixelRoutine::stencilTest(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask)
+ {
+ if(!state.stencilActive)
+ {
+ return;
+ }
+
+ // (StencilRef & StencilMask) CompFunc (StencilBufferValue & StencilMask)
+
+ Pointer<Byte> buffer = sBuffer + 2 * x;
+
+ if(q > 0)
+ {
+ buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,stencilSliceB));
+ }
+
+ Byte8 value = As<Byte8>(Long1(*Pointer<UInt>(buffer)));
+ Byte8 valueCCW = value;
+
+ if(!state.noStencilMask)
+ {
+ value &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[0].testMaskQ));
+ }
+
+ stencilTest(r, value, (Context::StencilCompareMode)state.stencilCompareMode, false);
+
+ if(state.twoSidedStencil)
+ {
+ if(!state.noStencilMaskCCW)
+ {
+ valueCCW &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[1].testMaskQ));
+ }
+
+ stencilTest(r, valueCCW, (Context::StencilCompareMode)state.stencilCompareModeCCW, true);
+
+ value &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,clockwiseMask));
+ valueCCW &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,invClockwiseMask));
+ value |= valueCCW;
+ }
+
+ sMask = SignMask(value) & cMask;
+ }
+
+ void PixelRoutine::stencilTest(Registers &r, Byte8 &value, Context::StencilCompareMode stencilCompareMode, bool CCW)
+ {
+ Byte8 equal;
+
+ switch(stencilCompareMode)
+ {
+ case Context::STENCIL_ALWAYS:
+ value = Byte8(0xFFFFFFFFFFFFFFFF);
+ break;
+ case Context::STENCIL_NEVER:
+ value = Byte8(0x0000000000000000);
+ break;
+ case Context::STENCIL_LESS: // a < b ~ b > a
+ value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+ value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
+ break;
+ case Context::STENCIL_EQUAL:
+ value = CmpEQ(value, *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
+ break;
+ case Context::STENCIL_NOTEQUAL: // a != b ~ !(a == b)
+ value = CmpEQ(value, *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
+ value ^= Byte8(0xFFFFFFFFFFFFFFFF);
+ break;
+ case Context::STENCIL_LESSEQUAL: // a <= b ~ (b > a) || (a == b)
+ equal = value;
+ equal = CmpEQ(equal, *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
+ value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+ value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
+ value |= equal;
+ break;
+ case Context::STENCIL_GREATER: // a > b
+ equal = *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ));
+ value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+ equal = CmpGT(As<SByte8>(equal), As<SByte8>(value));
+ value = equal;
+ break;
+ case Context::STENCIL_GREATEREQUAL: // a >= b ~ !(a < b) ~ !(b > a)
+ value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+ value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
+ value ^= Byte8(0xFFFFFFFFFFFFFFFF);
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ Bool PixelRoutine::depthTest(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask)
+ {
+ if(!state.depthTestActive)
+ {
+ return true;
+ }
+
+ Float4 Z = z;
+
+ if(pixelShader && pixelShader->depthOverride())
+ {
+ if(complementaryDepthBuffer)
+ {
+ Z = Float4(1, 1, 1, 1) - r.oDepth;
+ }
+ else
+ {
+ Z = r.oDepth;
+ }
+ }
+
+ Pointer<Byte> buffer;
+ Int pitch;
+
+ if(!state.quadLayoutDepthBuffer)
+ {
+ buffer = zBuffer + 4 * x;
+ pitch = *Pointer<Int>(r.data + OFFSET(DrawData,depthPitchB));
+ }
+ else
+ {
+ buffer = zBuffer + 8 * x;
+ }
+
+ if(q > 0)
+ {
+ buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,depthSliceB));
+ }
+
+ Float4 zValue;
+
+ if(state.depthCompareMode != Context::DEPTH_NEVER || (state.depthCompareMode != Context::DEPTH_ALWAYS && !state.depthWriteEnable))
+ {
+ if(!state.quadLayoutDepthBuffer)
+ {
+ // FIXME: Properly optimizes?
+ zValue.xy = *Pointer<Float4>(buffer);
+ zValue.zw = *Pointer<Float4>(buffer + pitch - 8);
+ }
+ else
+ {
+ zValue = *Pointer<Float4>(buffer, 16);
+ }
+ }
+
+ Int4 zTest;
+
+ switch(state.depthCompareMode)
+ {
+ case Context::DEPTH_ALWAYS:
+ // Optimized
+ break;
+ case Context::DEPTH_NEVER:
+ // Optimized
+ break;
+ case Context::DEPTH_EQUAL:
+ zTest = CmpEQ(zValue, Z);
+ break;
+ case Context::DEPTH_NOTEQUAL:
+ zTest = CmpNEQ(zValue, Z);
+ break;
+ case Context::DEPTH_LESS:
+ if(complementaryDepthBuffer)
+ {
+ zTest = CmpLT(zValue, Z);
+ }
+ else
+ {
+ zTest = CmpNLE(zValue, Z);
+ }
+ break;
+ case Context::DEPTH_GREATEREQUAL:
+ if(complementaryDepthBuffer)
+ {
+ zTest = CmpNLT(zValue, Z);
+ }
+ else
+ {
+ zTest = CmpLE(zValue, Z);
+ }
+ break;
+ case Context::DEPTH_LESSEQUAL:
+ if(complementaryDepthBuffer)
+ {
+ zTest = CmpLE(zValue, Z);
+ }
+ else
+ {
+ zTest = CmpNLT(zValue, Z);
+ }
+ break;
+ case Context::DEPTH_GREATER:
+ if(complementaryDepthBuffer)
+ {
+ zTest = CmpNLE(zValue, Z);
+ }
+ else
+ {
+ zTest = CmpLT(zValue, Z);
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(state.depthCompareMode)
+ {
+ case Context::DEPTH_ALWAYS:
+ zMask = cMask;
+ break;
+ case Context::DEPTH_NEVER:
+ zMask = 0x0;
+ break;
+ default:
+ zMask = SignMask(zTest) & cMask;
+ break;
+ }
+
+ if(state.stencilActive)
+ {
+ zMask &= sMask;
+ }
+
+ return zMask != 0;
+ }
+
+ void PixelRoutine::blendTexture(Registers &r, Color4i ¤t, Color4i &temp, Color4i &texture, int stage)
+ {
+ Color4i *arg1;
+ Color4i *arg2;
+ Color4i *arg3;
+ Color4i res;
+
+ Color4i constant;
+ Color4i tfactor;
+
+ const TextureStage::State &textureStage = state.textureStage[stage];
+
+ if(textureStage.firstArgument == TextureStage::SOURCE_CONSTANT ||
+ textureStage.firstArgumentAlpha == TextureStage::SOURCE_CONSTANT ||
+ textureStage.secondArgument == TextureStage::SOURCE_CONSTANT ||
+ textureStage.secondArgumentAlpha == TextureStage::SOURCE_CONSTANT ||
+ textureStage.thirdArgument == TextureStage::SOURCE_CONSTANT ||
+ textureStage.thirdArgumentAlpha == TextureStage::SOURCE_CONSTANT)
+ {
+ constant.r = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[0]));
+ constant.g = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[1]));
+ constant.b = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[2]));
+ constant.a = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[3]));
+ }
+
+ if(textureStage.firstArgument == TextureStage::SOURCE_TFACTOR ||
+ textureStage.firstArgumentAlpha == TextureStage::SOURCE_TFACTOR ||
+ textureStage.secondArgument == TextureStage::SOURCE_TFACTOR ||
+ textureStage.secondArgumentAlpha == TextureStage::SOURCE_TFACTOR ||
+ textureStage.thirdArgument == TextureStage::SOURCE_TFACTOR ||
+ textureStage.thirdArgumentAlpha == TextureStage::SOURCE_TFACTOR)
+ {
+ tfactor.r = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[0]));
+ tfactor.g = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[1]));
+ tfactor.b = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[2]));
+ tfactor.a = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]));
+ }
+
+ // Premodulate
+ if(stage > 0 && textureStage.usesTexture)
+ {
+ if(state.textureStage[stage - 1].stageOperation == TextureStage::STAGE_PREMODULATE)
+ {
+ current.r = MulHigh(current.r, texture.r) << 4;
+ current.g = MulHigh(current.g, texture.g) << 4;
+ current.b = MulHigh(current.b, texture.b) << 4;
+ }
+
+ if(state.textureStage[stage - 1].stageOperationAlpha == TextureStage::STAGE_PREMODULATE)
+ {
+ current.a = MulHigh(current.a, texture.a) << 4;
+ }
+ }
+
+ if(luminance)
+ {
+ texture.r = MulHigh(texture.r, r.L) << 4;
+ texture.g = MulHigh(texture.g, r.L) << 4;
+ texture.b = MulHigh(texture.b, r.L) << 4;
+
+ luminance = false;
+ }
+
+ switch(textureStage.firstArgument)
+ {
+ case TextureStage::SOURCE_TEXTURE: arg1 = &texture; break;
+ case TextureStage::SOURCE_CONSTANT: arg1 = &constant; break;
+ case TextureStage::SOURCE_CURRENT: arg1 = ¤t; break;
+ case TextureStage::SOURCE_DIFFUSE: arg1 = &r.diffuse; break;
+ case TextureStage::SOURCE_SPECULAR: arg1 = &r.specular; break;
+ case TextureStage::SOURCE_TEMP: arg1 = &temp; break;
+ case TextureStage::SOURCE_TFACTOR: arg1 = &tfactor; break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.secondArgument)
+ {
+ case TextureStage::SOURCE_TEXTURE: arg2 = &texture; break;
+ case TextureStage::SOURCE_CONSTANT: arg2 = &constant; break;
+ case TextureStage::SOURCE_CURRENT: arg2 = ¤t; break;
+ case TextureStage::SOURCE_DIFFUSE: arg2 = &r.diffuse; break;
+ case TextureStage::SOURCE_SPECULAR: arg2 = &r.specular; break;
+ case TextureStage::SOURCE_TEMP: arg2 = &temp; break;
+ case TextureStage::SOURCE_TFACTOR: arg2 = &tfactor; break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.thirdArgument)
+ {
+ case TextureStage::SOURCE_TEXTURE: arg3 = &texture; break;
+ case TextureStage::SOURCE_CONSTANT: arg3 = &constant; break;
+ case TextureStage::SOURCE_CURRENT: arg3 = ¤t; break;
+ case TextureStage::SOURCE_DIFFUSE: arg3 = &r.diffuse; break;
+ case TextureStage::SOURCE_SPECULAR: arg3 = &r.specular; break;
+ case TextureStage::SOURCE_TEMP: arg3 = &temp; break;
+ case TextureStage::SOURCE_TFACTOR: arg3 = &tfactor; break;
+ default:
+ ASSERT(false);
+ }
+
+ Color4i mod1;
+ Color4i mod2;
+ Color4i mod3;
+
+ switch(textureStage.firstModifier)
+ {
+ case TextureStage::MODIFIER_COLOR:
+ break;
+ case TextureStage::MODIFIER_INVCOLOR:
+ {
+ mod1.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->r);
+ mod1.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->g);
+ mod1.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->b);
+ mod1.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->a);
+
+ arg1 = &mod1;
+ }
+ break;
+ case TextureStage::MODIFIER_ALPHA:
+ {
+ mod1.r = arg1->a;
+ mod1.g = arg1->a;
+ mod1.b = arg1->a;
+ mod1.a = arg1->a;
+
+ arg1 = &mod1;
+ }
+ break;
+ case TextureStage::MODIFIER_INVALPHA:
+ {
+ mod1.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->a);
+ mod1.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->a);
+ mod1.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->a);
+ mod1.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->a);
+
+ arg1 = &mod1;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.secondModifier)
+ {
+ case TextureStage::MODIFIER_COLOR:
+ break;
+ case TextureStage::MODIFIER_INVCOLOR:
+ {
+ mod2.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->r);
+ mod2.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->g);
+ mod2.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->b);
+ mod2.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->a);
+
+ arg2 = &mod2;
+ }
+ break;
+ case TextureStage::MODIFIER_ALPHA:
+ {
+ mod2.r = arg2->a;
+ mod2.g = arg2->a;
+ mod2.b = arg2->a;
+ mod2.a = arg2->a;
+
+ arg2 = &mod2;
+ }
+ break;
+ case TextureStage::MODIFIER_INVALPHA:
+ {
+ mod2.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->a);
+ mod2.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->a);
+ mod2.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->a);
+ mod2.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->a);
+
+ arg2 = &mod2;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.thirdModifier)
+ {
+ case TextureStage::MODIFIER_COLOR:
+ break;
+ case TextureStage::MODIFIER_INVCOLOR:
+ {
+ mod3.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->r);
+ mod3.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->g);
+ mod3.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->b);
+ mod3.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->a);
+
+ arg3 = &mod3;
+ }
+ break;
+ case TextureStage::MODIFIER_ALPHA:
+ {
+ mod3.r = arg3->a;
+ mod3.g = arg3->a;
+ mod3.b = arg3->a;
+ mod3.a = arg3->a;
+
+ arg3 = &mod3;
+ }
+ break;
+ case TextureStage::MODIFIER_INVALPHA:
+ {
+ mod3.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->a);
+ mod3.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->a);
+ mod3.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->a);
+ mod3.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->a);
+
+ arg3 = &mod3;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.stageOperation)
+ {
+ case TextureStage::STAGE_DISABLE:
+ break;
+ case TextureStage::STAGE_SELECTARG1: // Arg1
+ {
+ res.r = arg1->r;
+ res.g = arg1->g;
+ res.b = arg1->b;
+ }
+ break;
+ case TextureStage::STAGE_SELECTARG2: // Arg2
+ {
+ res.r = arg2->r;
+ res.g = arg2->g;
+ res.b = arg2->b;
+ }
+ break;
+ case TextureStage::STAGE_SELECTARG3: // Arg3
+ {
+ res.r = arg3->r;
+ res.g = arg3->g;
+ res.b = arg3->b;
+ }
+ break;
+ case TextureStage::STAGE_MODULATE: // Arg1 * Arg2
+ {
+ res.r = MulHigh(arg1->r, arg2->r) << 4;
+ res.g = MulHigh(arg1->g, arg2->g) << 4;
+ res.b = MulHigh(arg1->b, arg2->b) << 4;
+ }
+ break;
+ case TextureStage::STAGE_MODULATE2X: // Arg1 * Arg2 * 2
+ {
+ res.r = MulHigh(arg1->r, arg2->r) << 5;
+ res.g = MulHigh(arg1->g, arg2->g) << 5;
+ res.b = MulHigh(arg1->b, arg2->b) << 5;
+ }
+ break;
+ case TextureStage::STAGE_MODULATE4X: // Arg1 * Arg2 * 4
+ {
+ res.r = MulHigh(arg1->r, arg2->r) << 6;
+ res.g = MulHigh(arg1->g, arg2->g) << 6;
+ res.b = MulHigh(arg1->b, arg2->b) << 6;
+ }
+ break;
+ case TextureStage::STAGE_ADD: // Arg1 + Arg2
+ {
+ res.r = AddSat(arg1->r, arg2->r);
+ res.g = AddSat(arg1->g, arg2->g);
+ res.b = AddSat(arg1->b, arg2->b);
+ }
+ break;
+ case TextureStage::STAGE_ADDSIGNED: // Arg1 + Arg2 - 0.5
+ {
+ res.r = AddSat(arg1->r, arg2->r);
+ res.g = AddSat(arg1->g, arg2->g);
+ res.b = AddSat(arg1->b, arg2->b);
+
+ res.r = SubSat(res.r, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ res.g = SubSat(res.g, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ res.b = SubSat(res.b, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ }
+ break;
+ case TextureStage::STAGE_ADDSIGNED2X: // (Arg1 + Arg2 - 0.5) << 1
+ {
+ res.r = AddSat(arg1->r, arg2->r);
+ res.g = AddSat(arg1->g, arg2->g);
+ res.b = AddSat(arg1->b, arg2->b);
+
+ res.r = SubSat(res.r, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ res.g = SubSat(res.g, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ res.b = SubSat(res.b, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+
+ res.r = AddSat(res.r, res.r);
+ res.g = AddSat(res.g, res.g);
+ res.b = AddSat(res.b, res.b);
+ }
+ break;
+ case TextureStage::STAGE_SUBTRACT: // Arg1 - Arg2
+ {
+ res.r = SubSat(arg1->r, arg2->r);
+ res.g = SubSat(arg1->g, arg2->g);
+ res.b = SubSat(arg1->b, arg2->b);
+ }
+ break;
+ case TextureStage::STAGE_ADDSMOOTH: // Arg1 + Arg2 - Arg1 * Arg2
+ {
+ Short4 tmp;
+
+ tmp = MulHigh(arg1->r, arg2->r) << 4; res.r = AddSat(arg1->r, arg2->r); res.r = SubSat(res.r, tmp);
+ tmp = MulHigh(arg1->g, arg2->g) << 4; res.g = AddSat(arg1->g, arg2->g); res.g = SubSat(res.g, tmp);
+ tmp = MulHigh(arg1->b, arg2->b) << 4; res.b = AddSat(arg1->b, arg2->b); res.b = SubSat(res.b, tmp);
+ }
+ break;
+ case TextureStage::STAGE_MULTIPLYADD: // Arg3 + Arg1 * Arg2
+ {
+ res.r = MulHigh(arg1->r, arg2->r) << 4; res.r = AddSat(res.r, arg3->r);
+ res.g = MulHigh(arg1->g, arg2->g) << 4; res.g = AddSat(res.g, arg3->g);
+ res.b = MulHigh(arg1->b, arg2->b) << 4; res.b = AddSat(res.b, arg3->b);
+ }
+ break;
+ case TextureStage::STAGE_LERP: // Arg3 * (Arg1 - Arg2) + Arg2
+ {
+ res.r = SubSat(arg1->r, arg2->r); res.r = MulHigh(res.r, arg3->r) << 4; res.r = AddSat(res.r, arg2->r);
+ res.g = SubSat(arg1->g, arg2->g); res.g = MulHigh(res.g, arg3->g) << 4; res.g = AddSat(res.g, arg2->g);
+ res.b = SubSat(arg1->b, arg2->b); res.b = MulHigh(res.b, arg3->b) << 4; res.b = AddSat(res.b, arg2->b);
+ }
+ break;
+ case TextureStage::STAGE_DOT3: // 2 * (Arg1.r - 0.5) * 2 * (Arg2.r - 0.5) + 2 * (Arg1.g - 0.5) * 2 * (Arg2.g - 0.5) + 2 * (Arg1.b - 0.5) * 2 * (Arg2.b - 0.5)
+ {
+ Short4 tmp;
+
+ res.r = SubSat(arg1->r, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->r, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.r = MulHigh(res.r, tmp);
+ res.g = SubSat(arg1->g, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->g, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.g = MulHigh(res.g, tmp);
+ res.b = SubSat(arg1->b, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->b, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.b = MulHigh(res.b, tmp);
+
+ res.r = res.r << 6;
+ res.g = res.g << 6;
+ res.b = res.b << 6;
+
+ res.r = AddSat(res.r, res.g);
+ res.r = AddSat(res.r, res.b);
+
+ // Clamp to [0, 1]
+ res.r = Max(res.r, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ res.r = Min(res.r, Short4(0x1000, 0x1000, 0x1000, 0x1000));
+
+ res.g = res.r;
+ res.b = res.r;
+ res.a = res.r;
+ }
+ break;
+ case TextureStage::STAGE_BLENDCURRENTALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+ {
+ res.r = SubSat(arg1->r, arg2->r); res.r = MulHigh(res.r, current.a) << 4; res.r = AddSat(res.r, arg2->r);
+ res.g = SubSat(arg1->g, arg2->g); res.g = MulHigh(res.g, current.a) << 4; res.g = AddSat(res.g, arg2->g);
+ res.b = SubSat(arg1->b, arg2->b); res.b = MulHigh(res.b, current.a) << 4; res.b = AddSat(res.b, arg2->b);
+ }
+ break;
+ case TextureStage::STAGE_BLENDDIFFUSEALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+ {
+ res.r = SubSat(arg1->r, arg2->r); res.r = MulHigh(res.r, r.diffuse.a) << 4; res.r = AddSat(res.r, arg2->r);
+ res.g = SubSat(arg1->g, arg2->g); res.g = MulHigh(res.g, r.diffuse.a) << 4; res.g = AddSat(res.g, arg2->g);
+ res.b = SubSat(arg1->b, arg2->b); res.b = MulHigh(res.b, r.diffuse.a) << 4; res.b = AddSat(res.b, arg2->b);
+ }
+ break;
+ case TextureStage::STAGE_BLENDFACTORALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+ {
+ res.r = SubSat(arg1->r, arg2->r); res.r = MulHigh(res.r, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.r = AddSat(res.r, arg2->r);
+ res.g = SubSat(arg1->g, arg2->g); res.g = MulHigh(res.g, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.g = AddSat(res.g, arg2->g);
+ res.b = SubSat(arg1->b, arg2->b); res.b = MulHigh(res.b, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.b = AddSat(res.b, arg2->b);
+ }
+ break;
+ case TextureStage::STAGE_BLENDTEXTUREALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+ {
+ res.r = SubSat(arg1->r, arg2->r); res.r = MulHigh(res.r, texture.a) << 4; res.r = AddSat(res.r, arg2->r);
+ res.g = SubSat(arg1->g, arg2->g); res.g = MulHigh(res.g, texture.a) << 4; res.g = AddSat(res.g, arg2->g);
+ res.b = SubSat(arg1->b, arg2->b); res.b = MulHigh(res.b, texture.a) << 4; res.b = AddSat(res.b, arg2->b);
+ }
+ break;
+ case TextureStage::STAGE_BLENDTEXTUREALPHAPM: // Arg1 + Arg2 * (1 - Alpha)
+ {
+ res.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), texture.a); res.r = MulHigh(res.r, arg2->r) << 4; res.r = AddSat(res.r, arg1->r);
+ res.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), texture.a); res.g = MulHigh(res.g, arg2->g) << 4; res.g = AddSat(res.g, arg1->g);
+ res.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), texture.a); res.b = MulHigh(res.b, arg2->b) << 4; res.b = AddSat(res.b, arg1->b);
+ }
+ break;
+ case TextureStage::STAGE_PREMODULATE:
+ {
+ res.r = arg1->r;
+ res.g = arg1->g;
+ res.b = arg1->b;
+ }
+ break;
+ case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR: // Arg1 + Arg1.a * Arg2
+ {
+ res.r = MulHigh(arg1->a, arg2->r) << 4; res.r = AddSat(res.r, arg1->r);
+ res.g = MulHigh(arg1->a, arg2->g) << 4; res.g = AddSat(res.g, arg1->g);
+ res.b = MulHigh(arg1->a, arg2->b) << 4; res.b = AddSat(res.b, arg1->b);
+ }
+ break;
+ case TextureStage::STAGE_MODULATECOLOR_ADDALPHA: // Arg1 * Arg2 + Arg1.a
+ {
+ res.r = MulHigh(arg1->r, arg2->r) << 4; res.r = AddSat(res.r, arg1->a);
+ res.g = MulHigh(arg1->g, arg2->g) << 4; res.g = AddSat(res.g, arg1->a);
+ res.b = MulHigh(arg1->b, arg2->b) << 4; res.b = AddSat(res.b, arg1->a);
+ }
+ break;
+ case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR: // (1 - Arg1.a) * Arg2 + Arg1
+ {
+ Short4 tmp;
+
+ res.r = AddSat(arg1->r, arg2->r); tmp = MulHigh(arg1->a, arg2->r) << 4; res.r = SubSat(res.r, tmp);
+ res.g = AddSat(arg1->g, arg2->g); tmp = MulHigh(arg1->a, arg2->g) << 4; res.g = SubSat(res.g, tmp);
+ res.b = AddSat(arg1->b, arg2->b); tmp = MulHigh(arg1->a, arg2->b) << 4; res.b = SubSat(res.b, tmp);
+ }
+ break;
+ case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA: // (1 - Arg1) * Arg2 + Arg1.a
+ {
+ Short4 tmp;
+
+ res.r = AddSat(arg1->a, arg2->r); tmp = MulHigh(arg1->r, arg2->r) << 4; res.r = SubSat(res.r, tmp);
+ res.g = AddSat(arg1->a, arg2->g); tmp = MulHigh(arg1->g, arg2->g) << 4; res.g = SubSat(res.g, tmp);
+ res.b = AddSat(arg1->a, arg2->b); tmp = MulHigh(arg1->b, arg2->b) << 4; res.b = SubSat(res.b, tmp);
+ }
+ break;
+ case TextureStage::STAGE_BUMPENVMAP:
+ {
+ r.du = Float4(texture.r) * Float4(1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0);
+ r.dv = Float4(texture.g) * Float4(1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0);
+
+ Float4 du2;
+ Float4 dv2;
+
+ du2 = r.du;
+ dv2 = r.dv;
+ r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
+ dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
+ r.du += dv2;
+ r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
+ du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
+ r.dv += du2;
+
+ perturbate = true;
+
+ res.r = r.current.r;
+ res.g = r.current.g;
+ res.b = r.current.b;
+ res.a = r.current.a;
+ }
+ break;
+ case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+ {
+ r.du = Float4(texture.r) * Float4(1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0);
+ r.dv = Float4(texture.g) * Float4(1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0, 1.0f / 0x0FE0);
+
+ Float4 du2;
+ Float4 dv2;
+
+ du2 = r.du;
+ dv2 = r.dv;
+
+ r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
+ dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
+ r.du += dv2;
+ r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
+ du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
+ r.dv += du2;
+
+ perturbate = true;
+
+ r.L = texture.b;
+ r.L = MulHigh(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceScale4)));
+ r.L = r.L << 4;
+ r.L = AddSat(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceOffset4)));
+ r.L = Max(r.L, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ r.L = Min(r.L, Short4(0x1000, 0x1000, 0x1000, 0x1000));
+
+ luminance = true;
+
+ res.r = r.current.r;
+ res.g = r.current.g;
+ res.b = r.current.b;
+ res.a = r.current.a;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ if(textureStage.stageOperation != TextureStage::STAGE_DOT3)
+ {
+ switch(textureStage.firstArgumentAlpha)
+ {
+ case TextureStage::SOURCE_TEXTURE: arg1 = &texture; break;
+ case TextureStage::SOURCE_CONSTANT: arg1 = &constant; break;
+ case TextureStage::SOURCE_CURRENT: arg1 = ¤t; break;
+ case TextureStage::SOURCE_DIFFUSE: arg1 = &r.diffuse; break;
+ case TextureStage::SOURCE_SPECULAR: arg1 = &r.specular; break;
+ case TextureStage::SOURCE_TEMP: arg1 = &temp; break;
+ case TextureStage::SOURCE_TFACTOR: arg1 = &tfactor; break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.secondArgumentAlpha)
+ {
+ case TextureStage::SOURCE_TEXTURE: arg2 = &texture; break;
+ case TextureStage::SOURCE_CONSTANT: arg2 = &constant; break;
+ case TextureStage::SOURCE_CURRENT: arg2 = ¤t; break;
+ case TextureStage::SOURCE_DIFFUSE: arg2 = &r.diffuse; break;
+ case TextureStage::SOURCE_SPECULAR: arg2 = &r.specular; break;
+ case TextureStage::SOURCE_TEMP: arg2 = &temp; break;
+ case TextureStage::SOURCE_TFACTOR: arg2 = &tfactor; break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.thirdArgumentAlpha)
+ {
+ case TextureStage::SOURCE_TEXTURE: arg3 = &texture; break;
+ case TextureStage::SOURCE_CONSTANT: arg3 = &constant; break;
+ case TextureStage::SOURCE_CURRENT: arg3 = ¤t; break;
+ case TextureStage::SOURCE_DIFFUSE: arg3 = &r.diffuse; break;
+ case TextureStage::SOURCE_SPECULAR: arg3 = &r.specular; break;
+ case TextureStage::SOURCE_TEMP: arg3 = &temp; break;
+ case TextureStage::SOURCE_TFACTOR: arg3 = &tfactor; break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.firstModifierAlpha) // FIXME: Check if actually used
+ {
+ case TextureStage::MODIFIER_COLOR:
+ break;
+ case TextureStage::MODIFIER_INVCOLOR:
+ {
+ mod1.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->a);
+
+ arg1 = &mod1;
+ }
+ break;
+ case TextureStage::MODIFIER_ALPHA:
+ {
+ // Redudant
+ }
+ break;
+ case TextureStage::MODIFIER_INVALPHA:
+ {
+ mod1.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg1->a);
+
+ arg1 = &mod1;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.secondModifierAlpha) // FIXME: Check if actually used
+ {
+ case TextureStage::MODIFIER_COLOR:
+ break;
+ case TextureStage::MODIFIER_INVCOLOR:
+ {
+ mod2.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->a);
+
+ arg2 = &mod2;
+ }
+ break;
+ case TextureStage::MODIFIER_ALPHA:
+ {
+ // Redudant
+ }
+ break;
+ case TextureStage::MODIFIER_INVALPHA:
+ {
+ mod2.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg2->a);
+
+ arg2 = &mod2;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.thirdModifierAlpha) // FIXME: Check if actually used
+ {
+ case TextureStage::MODIFIER_COLOR:
+ break;
+ case TextureStage::MODIFIER_INVCOLOR:
+ {
+ mod3.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->a);
+
+ arg3 = &mod3;
+ }
+ break;
+ case TextureStage::MODIFIER_ALPHA:
+ {
+ // Redudant
+ }
+ break;
+ case TextureStage::MODIFIER_INVALPHA:
+ {
+ mod3.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), arg3->a);
+
+ arg3 = &mod3;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.stageOperationAlpha)
+ {
+ case TextureStage::STAGE_DISABLE:
+ break;
+ case TextureStage::STAGE_SELECTARG1: // Arg1
+ {
+ res.a = arg1->a;
+ }
+ break;
+ case TextureStage::STAGE_SELECTARG2: // Arg2
+ {
+ res.a = arg2->a;
+ }
+ break;
+ case TextureStage::STAGE_SELECTARG3: // Arg3
+ {
+ res.a = arg3->a;
+ }
+ break;
+ case TextureStage::STAGE_MODULATE: // Arg1 * Arg2
+ {
+ res.a = MulHigh(arg1->a, arg2->a) << 4;
+ }
+ break;
+ case TextureStage::STAGE_MODULATE2X: // Arg1 * Arg2 * 2
+ {
+ res.a = MulHigh(arg1->a, arg2->a) << 5;
+ }
+ break;
+ case TextureStage::STAGE_MODULATE4X: // Arg1 * Arg2 * 4
+ {
+ res.a = MulHigh(arg1->a, arg2->a) << 6;
+ }
+ break;
+ case TextureStage::STAGE_ADD: // Arg1 + Arg2
+ {
+ res.a = AddSat(arg1->a, arg2->a);
+ }
+ break;
+ case TextureStage::STAGE_ADDSIGNED: // Arg1 + Arg2 - 0.5
+ {
+ res.a = AddSat(arg1->a, arg2->a);
+ res.a = SubSat(res.a, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ }
+ break;
+ case TextureStage::STAGE_ADDSIGNED2X: // (Arg1 + Arg2 - 0.5) << 1
+ {
+ res.a = AddSat(arg1->a, arg2->a);
+ res.a = SubSat(res.a, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ res.a = AddSat(res.a, res.a);
+ }
+ break;
+ case TextureStage::STAGE_SUBTRACT: // Arg1 - Arg2
+ {
+ res.a = SubSat(arg1->a, arg2->a);
+ }
+ break;
+ case TextureStage::STAGE_ADDSMOOTH: // Arg1 + Arg2 - Arg1 * Arg2
+ {
+ Short4 tmp;
+
+ tmp = MulHigh(arg1->a, arg2->a) << 4; res.a = AddSat(arg1->a, arg2->a); res.a = SubSat(res.a, tmp);
+ }
+ break;
+ case TextureStage::STAGE_MULTIPLYADD: // Arg3 + Arg1 * Arg2
+ {
+ res.a = MulHigh(arg1->a, arg2->a) << 4; res.a = AddSat(res.a, arg3->a);
+ }
+ break;
+ case TextureStage::STAGE_LERP: // Arg3 * (Arg1 - Arg2) + Arg2
+ {
+ res.a = SubSat(arg1->a, arg2->a); res.a = MulHigh(res.a, arg3->a) << 4; res.a = AddSat(res.a, arg2->a);
+ }
+ break;
+ case TextureStage::STAGE_DOT3:
+ break; // Already computed in color channel
+ case TextureStage::STAGE_BLENDCURRENTALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+ {
+ res.a = SubSat(arg1->a, arg2->a); res.a = MulHigh(res.a, current.a) << 4; res.a = AddSat(res.a, arg2->a);
+ }
+ break;
+ case TextureStage::STAGE_BLENDDIFFUSEALPHA: // Arg1 * (Alpha) + Arg2 * (1 - Alpha)
+ {
+ res.a = SubSat(arg1->a, arg2->a); res.a = MulHigh(res.a, r.diffuse.a) << 4; res.a = AddSat(res.a, arg2->a);
+ }
+ break;
+ case TextureStage::STAGE_BLENDFACTORALPHA:
+ {
+ res.a = SubSat(arg1->a, arg2->a); res.a = MulHigh(res.a, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]))) << 4; res.a = AddSat(res.a, arg2->a);
+ }
+ break;
+ case TextureStage::STAGE_BLENDTEXTUREALPHA: // Arg1 * (Alpha) + Arg2 * (1 - Alpha)
+ {
+ res.a = SubSat(arg1->a, arg2->a); res.a = MulHigh(res.a, texture.a) << 4; res.a = AddSat(res.a, arg2->a);
+ }
+ break;
+ case TextureStage::STAGE_BLENDTEXTUREALPHAPM: // Arg1 + Arg2 * (1 - Alpha)
+ {
+ res.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), texture.a); res.a = MulHigh(res.a, arg2->a) << 4; res.a = AddSat(res.a, arg1->a);
+ }
+ break;
+ case TextureStage::STAGE_PREMODULATE:
+ {
+ res.a = arg1->a;
+ }
+ break;
+ case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+ case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+ case TextureStage::STAGE_BUMPENVMAP:
+ case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+ break; // Invalid alpha operations
+ default:
+ ASSERT(false);
+ }
+ }
+
+ // Clamp result to [0, 1]
+
+ switch(textureStage.stageOperation)
+ {
+ case TextureStage::STAGE_DISABLE:
+ case TextureStage::STAGE_SELECTARG1:
+ case TextureStage::STAGE_SELECTARG2:
+ case TextureStage::STAGE_SELECTARG3:
+ case TextureStage::STAGE_MODULATE:
+ case TextureStage::STAGE_MODULATE2X:
+ case TextureStage::STAGE_MODULATE4X:
+ case TextureStage::STAGE_ADD:
+ case TextureStage::STAGE_MULTIPLYADD:
+ case TextureStage::STAGE_LERP:
+ case TextureStage::STAGE_BLENDCURRENTALPHA:
+ case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+ case TextureStage::STAGE_BLENDFACTORALPHA:
+ case TextureStage::STAGE_BLENDTEXTUREALPHA:
+ case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+ case TextureStage::STAGE_DOT3: // Already clamped
+ case TextureStage::STAGE_PREMODULATE:
+ case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+ case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+ case TextureStage::STAGE_BUMPENVMAP:
+ case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+ if(state.textureStage[stage].cantUnderflow)
+ {
+ break; // Can't go below zero
+ }
+ case TextureStage::STAGE_ADDSIGNED:
+ case TextureStage::STAGE_ADDSIGNED2X:
+ case TextureStage::STAGE_SUBTRACT:
+ case TextureStage::STAGE_ADDSMOOTH:
+ res.r = Max(res.r, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ res.g = Max(res.g, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ res.b = Max(res.b, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.stageOperationAlpha)
+ {
+ case TextureStage::STAGE_DISABLE:
+ case TextureStage::STAGE_SELECTARG1:
+ case TextureStage::STAGE_SELECTARG2:
+ case TextureStage::STAGE_SELECTARG3:
+ case TextureStage::STAGE_MODULATE:
+ case TextureStage::STAGE_MODULATE2X:
+ case TextureStage::STAGE_MODULATE4X:
+ case TextureStage::STAGE_ADD:
+ case TextureStage::STAGE_MULTIPLYADD:
+ case TextureStage::STAGE_LERP:
+ case TextureStage::STAGE_BLENDCURRENTALPHA:
+ case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+ case TextureStage::STAGE_BLENDFACTORALPHA:
+ case TextureStage::STAGE_BLENDTEXTUREALPHA:
+ case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+ case TextureStage::STAGE_DOT3: // Already clamped
+ case TextureStage::STAGE_PREMODULATE:
+ case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+ case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+ case TextureStage::STAGE_BUMPENVMAP:
+ case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+ if(state.textureStage[stage].cantUnderflow)
+ {
+ break; // Can't go below zero
+ }
+ case TextureStage::STAGE_ADDSIGNED:
+ case TextureStage::STAGE_ADDSIGNED2X:
+ case TextureStage::STAGE_SUBTRACT:
+ case TextureStage::STAGE_ADDSMOOTH:
+ res.a = Max(res.a, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.stageOperation)
+ {
+ case TextureStage::STAGE_DISABLE:
+ case TextureStage::STAGE_SELECTARG1:
+ case TextureStage::STAGE_SELECTARG2:
+ case TextureStage::STAGE_SELECTARG3:
+ case TextureStage::STAGE_MODULATE:
+ case TextureStage::STAGE_SUBTRACT:
+ case TextureStage::STAGE_ADDSMOOTH:
+ case TextureStage::STAGE_LERP:
+ case TextureStage::STAGE_BLENDCURRENTALPHA:
+ case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+ case TextureStage::STAGE_BLENDFACTORALPHA:
+ case TextureStage::STAGE_BLENDTEXTUREALPHA:
+ case TextureStage::STAGE_DOT3: // Already clamped
+ case TextureStage::STAGE_PREMODULATE:
+ case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+ case TextureStage::STAGE_BUMPENVMAP:
+ case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+ break; // Can't go above one
+ case TextureStage::STAGE_MODULATE2X:
+ case TextureStage::STAGE_MODULATE4X:
+ case TextureStage::STAGE_ADD:
+ case TextureStage::STAGE_ADDSIGNED:
+ case TextureStage::STAGE_ADDSIGNED2X:
+ case TextureStage::STAGE_MULTIPLYADD:
+ case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+ case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+ res.r = Min(res.r, Short4(0x1000, 0x1000, 0x1000, 0x1000));
+ res.g = Min(res.g, Short4(0x1000, 0x1000, 0x1000, 0x1000));
+ res.b = Min(res.b, Short4(0x1000, 0x1000, 0x1000, 0x1000));
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.stageOperationAlpha)
+ {
+ case TextureStage::STAGE_DISABLE:
+ case TextureStage::STAGE_SELECTARG1:
+ case TextureStage::STAGE_SELECTARG2:
+ case TextureStage::STAGE_SELECTARG3:
+ case TextureStage::STAGE_MODULATE:
+ case TextureStage::STAGE_SUBTRACT:
+ case TextureStage::STAGE_ADDSMOOTH:
+ case TextureStage::STAGE_LERP:
+ case TextureStage::STAGE_BLENDCURRENTALPHA:
+ case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+ case TextureStage::STAGE_BLENDFACTORALPHA:
+ case TextureStage::STAGE_BLENDTEXTUREALPHA:
+ case TextureStage::STAGE_DOT3: // Already clamped
+ case TextureStage::STAGE_PREMODULATE:
+ case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+ case TextureStage::STAGE_BUMPENVMAP:
+ case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+ break; // Can't go above one
+ case TextureStage::STAGE_MODULATE2X:
+ case TextureStage::STAGE_MODULATE4X:
+ case TextureStage::STAGE_ADD:
+ case TextureStage::STAGE_ADDSIGNED:
+ case TextureStage::STAGE_ADDSIGNED2X:
+ case TextureStage::STAGE_MULTIPLYADD:
+ case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+ case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+ case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+ res.a = Min(res.a, Short4(0x1000, 0x1000, 0x1000, 0x1000));
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ switch(textureStage.destinationArgument)
+ {
+ case TextureStage::DESTINATION_CURRENT:
+ current.r = res.r;
+ current.g = res.g;
+ current.b = res.b;
+ current.a = res.a;
+ break;
+ case TextureStage::DESTINATION_TEMP:
+ temp.r = res.r;
+ temp.g = res.g;
+ temp.b = res.b;
+ temp.a = res.a;
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::alphaTest(Registers &r, Int &aMask, Short4 &alpha)
+ {
+ Short4 cmp;
+ Short4 equal;
+
+ switch(state.alphaCompareMode)
+ {
+ case Context::ALPHA_ALWAYS:
+ aMask = 0xF;
+ break;
+ case Context::ALPHA_NEVER:
+ aMask = 0x0;
+ break;
+ case Context::ALPHA_EQUAL:
+ cmp = CmpEQ(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
+ aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ break;
+ case Context::ALPHA_NOTEQUAL: // a != b ~ !(a == b)
+ cmp = CmpEQ(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4((short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF); // FIXME
+ aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ break;
+ case Context::ALPHA_LESS: // a < b ~ b > a
+ cmp = CmpGT(*Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)), alpha);
+ aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ break;
+ case Context::ALPHA_GREATEREQUAL: // a >= b ~ (a > b) || (a == b) ~ !(b > a) // TODO: Approximate
+ equal = CmpEQ(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
+ cmp = CmpGT(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
+ cmp |= equal;
+ aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ break;
+ case Context::ALPHA_LESSEQUAL: // a <= b ~ !(a > b)
+ cmp = CmpGT(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4((short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF); // FIXME
+ aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ break;
+ case Context::ALPHA_GREATER: // a > b
+ cmp = CmpGT(alpha, *Pointer<Short4>(r.data + OFFSET(DrawData,factor.alphaReference4)));
+ aMask = SignMask(Pack(cmp, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::alphaToCoverage(Registers &r, Int cMask[4], Float4 &alpha)
+ {
+ Int4 coverage0 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c0)));
+ Int4 coverage1 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c1)));
+ Int4 coverage2 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c2)));
+ Int4 coverage3 = CmpNLT(alpha, *Pointer<Float4>(r.data + OFFSET(DrawData,a2c3)));
+
+ Int aMask0 = SignMask(coverage0);
+ Int aMask1 = SignMask(coverage1);
+ Int aMask2 = SignMask(coverage2);
+ Int aMask3 = SignMask(coverage3);
+
+ cMask[0] &= aMask0;
+ cMask[1] &= aMask1;
+ cMask[2] &= aMask2;
+ cMask[3] &= aMask3;
+ }
+
+ Bool PixelRoutine::alphaTest(Registers &r, Int cMask[4], Color4i ¤t)
+ {
+ if(!state.alphaTestActive())
+ {
+ return true;
+ }
+
+ Int aMask;
+
+ if(state.transparencyAntialiasing == Context::TRANSPARENCY_NONE)
+ {
+ alphaTest(r, aMask, current.a);
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ cMask[q] &= aMask;
+ }
+ }
+ else if(state.transparencyAntialiasing == Context::TRANSPARENCY_ALPHA_TO_COVERAGE)
+ {
+ Float4 alpha = Float4(current.a) * Float4(1.0f / 0x1000);
+
+ alphaToCoverage(r, cMask, alpha);
+ }
+ else ASSERT(false);
+
+ Int pass = cMask[0];
+
+ for(unsigned int q = 1; q < state.multiSample; q++)
+ {
+ pass = pass | cMask[q];
+ }
+
+ return pass != 0x0;
+ }
+
+ Bool PixelRoutine::alphaTest(Registers &r, Int cMask[4], Color4f &c0)
+ {
+ if(!state.alphaTestActive())
+ {
+ return true;
+ }
+
+ Int aMask;
+
+ if(state.transparencyAntialiasing == Context::TRANSPARENCY_NONE)
+ {
+ Short4 alpha = RoundShort4(c0.a * Float4(0x1000, 0x1000, 0x1000, 0x1000));
+
+ alphaTest(r, aMask, alpha);
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ cMask[q] &= aMask;
+ }
+ }
+ else if(state.transparencyAntialiasing == Context::TRANSPARENCY_ALPHA_TO_COVERAGE)
+ {
+ alphaToCoverage(r, cMask, c0.a);
+ }
+ else ASSERT(false);
+
+ Int pass = cMask[0];
+
+ for(unsigned int q = 1; q < state.multiSample; q++)
+ {
+ pass = pass | cMask[q];
+ }
+
+ return pass != 0x0;
+ }
+
+ void PixelRoutine::fogBlend(Registers &r, Color4i ¤t, Float4 &f, Float4 &z, Float4 &rhw)
+ {
+ if(!state.fogActive)
+ {
+ return;
+ }
+
+ if(state.pixelFogMode != Context::FOG_NONE)
+ {
+ pixelFog(r, f, z, rhw);
+ }
+
+ UShort4 fog = convertFixed16(f, true);
+
+ current.r = As<Short4>(MulHigh(As<UShort4>(current.r), fog));
+ current.g = As<Short4>(MulHigh(As<UShort4>(current.g), fog));
+ current.b = As<Short4>(MulHigh(As<UShort4>(current.b), fog));
+
+ UShort4 invFog = UShort4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - fog;
+
+ current.r += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[0]))));
+ current.g += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[1]))));
+ current.b += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[2]))));
+ }
+
+ void PixelRoutine::fogBlend(Registers &r, Color4f &c0, Float4 &fog, Float4 &z, Float4 &rhw)
+ {
+ if(!state.fogActive)
+ {
+ return;
+ }
+
+ if(state.pixelFogMode != Context::FOG_NONE)
+ {
+ pixelFog(r, fog, z, rhw);
+
+ fog = Min(fog, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ fog = Max(fog, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ }
+
+ c0.r -= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[0]));
+ c0.g -= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[1]));
+ c0.b -= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[2]));
+
+ c0.r *= fog;
+ c0.g *= fog;
+ c0.b *= fog;
+
+ c0.r += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[0]));
+ c0.g += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[1]));
+ c0.b += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.colorF[2]));
+ }
+
+ void PixelRoutine::pixelFog(Registers &r, Float4 &visibility, Float4 &z, Float4 &rhw)
+ {
+ Float4 &zw = visibility;
+
+ if(state.pixelFogMode != Context::FOG_NONE)
+ {
+ if(state.wBasedFog)
+ {
+ zw = rhw;
+ }
+ else
+ {
+ if(complementaryDepthBuffer)
+ {
+ zw = Float4(1.0f, 1.0f, 1.0f, 1.0f) - z;
+ }
+ else
+ {
+ zw = z;
+ }
+ }
+ }
+
+ switch(state.pixelFogMode)
+ {
+ case Context::FOG_NONE:
+ break;
+ case Context::FOG_LINEAR:
+ zw *= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.scale));
+ zw += *Pointer<Float4>(r.data + OFFSET(DrawData,fog.offset));
+ break;
+ case Context::FOG_EXP:
+ zw *= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.densityE));
+ zw = exponential(zw, true);
+ break;
+ case Context::FOG_EXP2:
+ zw *= *Pointer<Float4>(r.data + OFFSET(DrawData,fog.densityE2));
+ zw *= zw;
+ zw = exponential(zw, true);
+ zw = Rcp_pp(zw);
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::specularPixel(Color4i ¤t, Color4i &specular)
+ {
+ if(!state.specularAdd)
+ {
+ return;
+ }
+
+ current.r = AddSat(current.r, specular.r);
+ current.g = AddSat(current.g, specular.g);
+ current.b = AddSat(current.b, specular.b);
+ }
+
+ void PixelRoutine::writeDepth(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask)
+ {
+ if(!state.depthWriteEnable)
+ {
+ return;
+ }
+
+ Float4 Z = z;
+
+ if(pixelShader && pixelShader->depthOverride())
+ {
+ if(complementaryDepthBuffer)
+ {
+ Z = Float4(1, 1, 1, 1) - r.oDepth;
+ }
+ else
+ {
+ Z = r.oDepth;
+ }
+ }
+
+ Pointer<Byte> buffer;
+ Int pitch;
+
+ if(!state.quadLayoutDepthBuffer)
+ {
+ buffer = zBuffer + 4 * x;
+ pitch = *Pointer<Int>(r.data + OFFSET(DrawData,depthPitchB));
+ }
+ else
+ {
+ buffer = zBuffer + 8 * x;
+ }
+
+ if(q > 0)
+ {
+ buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,depthSliceB));
+ }
+
+ Float4 zValue;
+
+ if(state.depthCompareMode != Context::DEPTH_NEVER || (state.depthCompareMode != Context::DEPTH_ALWAYS && !state.depthWriteEnable))
+ {
+ if(!state.quadLayoutDepthBuffer)
+ {
+ // FIXME: Properly optimizes?
+ zValue.xy = *Pointer<Float4>(buffer);
+ zValue.zw = *Pointer<Float4>(buffer + pitch - 8);
+ }
+ else
+ {
+ zValue = *Pointer<Float4>(buffer, 16);
+ }
+ }
+
+ Z = As<Float4>(As<Int4>(Z) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X) + zMask * 16, 16));
+ zValue = As<Float4>(As<Int4>(zValue) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X) + zMask * 16, 16));
+ Z = As<Float4>(As<Int4>(Z) | As<Int4>(zValue));
+
+ if(!state.quadLayoutDepthBuffer)
+ {
+ // FIXME: Properly optimizes?
+ *Pointer<Float2>(buffer) = Float2(Z.xy);
+ *Pointer<Float2>(buffer + pitch) = Float2(Z.zw);
+ }
+ else
+ {
+ *Pointer<Float4>(buffer, 16) = Z;
+ }
+ }
+
+ void PixelRoutine::writeStencil(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask)
+ {
+ if(!state.stencilActive)
+ {
+ return;
+ }
+
+ if(state.stencilPassOperation == Context::OPERATION_KEEP && state.stencilZFailOperation == Context::OPERATION_KEEP && state.stencilFailOperation == Context::OPERATION_KEEP)
+ {
+ if(!state.twoSidedStencil || (state.stencilPassOperationCCW == Context::OPERATION_KEEP && state.stencilZFailOperationCCW == Context::OPERATION_KEEP && state.stencilFailOperationCCW == Context::OPERATION_KEEP))
+ {
+ return;
+ }
+ }
+
+ if(state.stencilWriteMasked && (!state.twoSidedStencil || state.stencilWriteMaskedCCW))
+ {
+ return;
+ }
+
+ Pointer<Byte> buffer = sBuffer + 2 * x;
+
+ if(q > 0)
+ {
+ buffer += q * *Pointer<Int>(r.data + OFFSET(DrawData,stencilSliceB));
+ }
+
+ Byte8 bufferValue = As<Byte8>(Long1(*Pointer<UInt>(buffer)));
+
+ Byte8 newValue;
+ stencilOperation(r, newValue, bufferValue, (Context::StencilOperation)state.stencilPassOperation, (Context::StencilOperation)state.stencilZFailOperation, (Context::StencilOperation)state.stencilFailOperation, false, zMask, sMask);
+
+ if(!state.noStencilWriteMask)
+ {
+ Byte8 maskedValue = bufferValue;
+ newValue &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[0].writeMaskQ));
+ maskedValue &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[0].invWriteMaskQ));
+ newValue |= maskedValue;
+ }
+
+ if(state.twoSidedStencil)
+ {
+ Byte8 newValueCCW;
+
+ stencilOperation(r, newValueCCW, bufferValue, (Context::StencilOperation)state.stencilPassOperationCCW, (Context::StencilOperation)state.stencilZFailOperationCCW, (Context::StencilOperation)state.stencilFailOperationCCW, true, zMask, sMask);
+
+ if(!state.noStencilWriteMaskCCW)
+ {
+ Byte8 maskedValue = bufferValue;
+ newValueCCW &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[1].writeMaskQ));
+ maskedValue &= *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[1].invWriteMaskQ));
+ newValueCCW |= maskedValue;
+ }
+
+ newValue &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,clockwiseMask));
+ newValueCCW &= *Pointer<Byte8>(r.primitive + OFFSET(Primitive,invClockwiseMask));
+ newValue |= newValueCCW;
+ }
+
+ newValue &= *Pointer<Byte8>(r.constants + OFFSET(Constants,maskB4Q) + 8 * cMask);
+ bufferValue &= *Pointer<Byte8>(r.constants + OFFSET(Constants,invMaskB4Q) + 8 * cMask);
+ newValue |= bufferValue;
+
+ *Pointer<UInt>(buffer) = UInt(As<Long>(newValue));
+ }
+
+ void PixelRoutine::stencilOperation(Registers &r, Byte8 &newValue, Byte8 &bufferValue, Context::StencilOperation stencilPassOperation, Context::StencilOperation stencilZFailOperation, Context::StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask)
+ {
+ Byte8 &pass = newValue;
+ Byte8 fail;
+ Byte8 zFail;
+
+ stencilOperation(r, pass, bufferValue, stencilPassOperation, CCW);
+
+ if(stencilZFailOperation != stencilPassOperation)
+ {
+ stencilOperation(r, zFail, bufferValue, stencilZFailOperation, CCW);
+ }
+
+ if(stencilFailOperation != stencilPassOperation || stencilFailOperation != stencilZFailOperation)
+ {
+ stencilOperation(r, fail, bufferValue, stencilFailOperation, CCW);
+ }
+
+ if(stencilFailOperation != stencilPassOperation || stencilFailOperation != stencilZFailOperation)
+ {
+ if(state.depthTestActive && stencilZFailOperation != stencilPassOperation) // zMask valid and values not the same
+ {
+ pass &= *Pointer<Byte8>(r.constants + OFFSET(Constants,maskB4Q) + 8 * zMask);
+ zFail &= *Pointer<Byte8>(r.constants + OFFSET(Constants,invMaskB4Q) + 8 * zMask);
+ pass |= zFail;
+ }
+
+ pass &= *Pointer<Byte8>(r.constants + OFFSET(Constants,maskB4Q) + 8 * sMask);
+ fail &= *Pointer<Byte8>(r.constants + OFFSET(Constants,invMaskB4Q) + 8 * sMask);
+ pass |= fail;
+ }
+ }
+
+ void PixelRoutine::stencilOperation(Registers &r, Byte8 &output, Byte8 &bufferValue, Context::StencilOperation operation, bool CCW)
+ {
+ switch(operation)
+ {
+ case Context::OPERATION_KEEP:
+ output = bufferValue;
+ break;
+ case Context::OPERATION_ZERO:
+ output = Byte8(0x0000000000000000);
+ break;
+ case Context::OPERATION_REPLACE:
+ output = *Pointer<Byte8>(r.data + OFFSET(DrawData,stencil[CCW].referenceQ));
+ break;
+ case Context::OPERATION_INCRSAT:
+ output = AddSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
+ break;
+ case Context::OPERATION_DECRSAT:
+ output = SubSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
+ break;
+ case Context::OPERATION_INVERT:
+ output = bufferValue ^ Byte8(0xFFFFFFFFFFFFFFFF);
+ break;
+ case Context::OPERATION_INCR:
+ output = bufferValue + Byte8(1, 1, 1, 1, 1, 1, 1, 1);
+ break;
+ case Context::OPERATION_DECR:
+ output = bufferValue - Byte8(1, 1, 1, 1, 1, 1, 1, 1);
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::sampleTexture(Registers &r, Color4i &c, int coordinates, int stage, bool project)
+ {
+ Float4 u = r.vx[2 + coordinates];
+ Float4 v = r.vy[2 + coordinates];
+ Float4 w = r.vz[2 + coordinates];
+ Float4 q = r.vw[2 + coordinates];
+
+ if(perturbate)
+ {
+ u += r.du;
+ v += r.dv;
+
+ perturbate = false;
+ }
+
+ sampleTexture(r, c, stage, u, v, w, q, project);
+ }
+
+ void PixelRoutine::sampleTexture(Registers &r, Color4i &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project, bool bias, bool fixed12)
+ {
+ Color4f dsx;
+ Color4f dsy;
+
+ sampleTexture(r, c, stage, u, v, w, q, dsx, dsy, project, bias, fixed12, false);
+ }
+
+ void PixelRoutine::sampleTexture(Registers &r, Color4i &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool project, bool bias, bool fixed12, bool gradients, bool lodProvided)
+ {
+ #if PERF_PROFILE
+ Long texTime = Ticks();
+ #endif
+
+ Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap) + stage * sizeof(Texture);
+
+ if(!project)
+ {
+ sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, fixed12, gradients, lodProvided);
+ }
+ else
+ {
+ Float4 rq = reciprocal(q);
+
+ Float4 u_q = u * rq;
+ Float4 v_q = v * rq;
+ Float4 w_q = w * rq;
+
+ sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, fixed12, gradients, lodProvided);
+ }
+
+ #if PERF_PROFILE
+ r.cycles[PERF_TEX] += Ticks() - texTime;
+ #endif
+ }
+
+ void PixelRoutine::sampleTexture(Registers &r, Color4f &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
+ {
+ #if PERF_PROFILE
+ Long texTime = Ticks();
+ #endif
+
+ Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap) + stage * sizeof(Texture);
+
+ if(!project)
+ {
+ sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
+ }
+ else
+ {
+ Float4 rq = reciprocal(q);
+
+ Float4 u_q = u * rq;
+ Float4 v_q = v * rq;
+ Float4 w_q = w * rq;
+
+ sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, gradients, lodProvided);
+ }
+
+ #if PERF_PROFILE
+ r.cycles[PERF_TEX] += Ticks() - texTime;
+ #endif
+ }
+
+ void PixelRoutine::clampColor(Color4f oC[4])
+ {
+ for(int index = 0; index < 4; index++)
+ {
+ if(!state.colorWriteActive(index) && !(index == 0 && state.alphaTestActive()))
+ {
+ continue;
+ }
+
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_NULL:
+ break;
+ case FORMAT_A16B16G16R16:
+ case FORMAT_A8R8G8B8:
+ case FORMAT_X8R8G8B8:
+ case FORMAT_G16R16:
+ oC[index].r = Max(oC[index].r, Float4(0.0f, 0.0f, 0.0f, 0.0f)); oC[index].r = Min(oC[index].r, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ oC[index].g = Max(oC[index].g, Float4(0.0f, 0.0f, 0.0f, 0.0f)); oC[index].g = Min(oC[index].g, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ oC[index].b = Max(oC[index].b, Float4(0.0f, 0.0f, 0.0f, 0.0f)); oC[index].b = Min(oC[index].b, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ oC[index].a = Max(oC[index].a, Float4(0.0f, 0.0f, 0.0f, 0.0f)); oC[index].a = Min(oC[index].a, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ break;
+ case FORMAT_R32F:
+ case FORMAT_G32R32F:
+ case FORMAT_A32B32G32R32F:
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+
+ void PixelRoutine::rasterOperation(Color4i ¤t, Registers &r, Float4 &fog, Pointer<Byte> &cBuffer, Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
+ {
+ if(!state.colorWriteActive(0))
+ {
+ return;
+ }
+
+ Color4f oC;
+
+ switch(state.targetFormat[0])
+ {
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ case FORMAT_G16R16:
+ case FORMAT_A16B16G16R16:
+ if(!postBlendSRGB && state.writeSRGB)
+ {
+ linearToSRGB12_16(r, current);
+ }
+ else
+ {
+ current.r <<= 4;
+ current.g <<= 4;
+ current.b <<= 4;
+ current.a <<= 4;
+ }
+
+ fogBlend(r, current, fog, r.z[0], r.rhw);
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ Pointer<Byte> buffer = cBuffer + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[0]));
+ Color4i color = current;
+
+ if(state.multiSampleMask & (1 << q))
+ {
+ alphaBlend(r, 0, buffer, color, x);
+ writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+ }
+ }
+ break;
+ case FORMAT_R32F:
+ case FORMAT_G32R32F:
+ case FORMAT_A32B32G32R32F:
+ convertSigned12(oC, current);
+ fogBlend(r, oC, fog, r.z[0], r.rhw);
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ Pointer<Byte> buffer = cBuffer + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[0]));
+ Color4f color = oC;
+
+ if(state.multiSampleMask & (1 << q))
+ {
+ alphaBlend(r, 0, buffer, color, x);
+ writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+ }
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::rasterOperation(Color4f oC[4], Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
+ {
+ for(int index = 0; index < 4; index++)
+ {
+ if(!state.colorWriteActive(index))
+ {
+ continue;
+ }
+
+ if(!postBlendSRGB && state.writeSRGB)
+ {
+ oC[index].r = linearToSRGB(oC[index].r);
+ oC[index].g = linearToSRGB(oC[index].g);
+ oC[index].b = linearToSRGB(oC[index].b);
+ }
+
+ if(index == 0)
+ {
+ fogBlend(r, oC[index], fog, r.z[0], r.rhw);
+ }
+
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ case FORMAT_G16R16:
+ case FORMAT_A16B16G16R16:
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[index]));
+ Color4i color;
+
+ color.r = convertFixed16(oC[index].r, false);
+ color.g = convertFixed16(oC[index].g, false);
+ color.b = convertFixed16(oC[index].b, false);
+ color.a = convertFixed16(oC[index].a, false);
+
+ if(state.multiSampleMask & (1 << q))
+ {
+ alphaBlend(r, index, buffer, color, x);
+ writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+ }
+ }
+ break;
+ case FORMAT_R32F:
+ case FORMAT_G32R32F:
+ case FORMAT_A32B32G32R32F:
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[index]));
+ Color4f color = oC[index];
+
+ if(state.multiSampleMask & (1 << q))
+ {
+ alphaBlend(r, index, buffer, color, x);
+ writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+ }
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+
+ void PixelRoutine::blendFactor(Registers &r, const Color4i &blendFactor, const Color4i ¤t, const Color4i &pixel, Context::BlendFactor blendFactorActive)
+ {
+ switch(blendFactorActive)
+ {
+ case Context::BLEND_ZERO:
+ // Optimized
+ break;
+ case Context::BLEND_ONE:
+ // Optimized
+ break;
+ case Context::BLEND_SOURCE:
+ blendFactor.r = current.r;
+ blendFactor.g = current.g;
+ blendFactor.b = current.b;
+ break;
+ case Context::BLEND_INVSOURCE:
+ blendFactor.r = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.r;
+ blendFactor.g = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.g;
+ blendFactor.b = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.b;
+ break;
+ case Context::BLEND_DEST:
+ blendFactor.r = pixel.r;
+ blendFactor.g = pixel.g;
+ blendFactor.b = pixel.b;
+ break;
+ case Context::BLEND_INVDEST:
+ blendFactor.r = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.r;
+ blendFactor.g = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.g;
+ blendFactor.b = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.b;
+ break;
+ case Context::BLEND_SOURCEALPHA:
+ blendFactor.r = current.a;
+ blendFactor.g = current.a;
+ blendFactor.b = current.a;
+ break;
+ case Context::BLEND_INVSOURCEALPHA:
+ blendFactor.r = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.a;
+ blendFactor.g = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.a;
+ blendFactor.b = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.a;
+ break;
+ case Context::BLEND_DESTALPHA:
+ blendFactor.r = pixel.a;
+ blendFactor.g = pixel.a;
+ blendFactor.b = pixel.a;
+ break;
+ case Context::BLEND_INVDESTALPHA:
+ blendFactor.r = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.a;
+ blendFactor.g = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.a;
+ blendFactor.b = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.a;
+ break;
+ case Context::BLEND_SRCALPHASAT:
+ blendFactor.r = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.a;
+ blendFactor.r = Min(As<UShort4>(blendFactor.r), As<UShort4>(current.a));
+ blendFactor.g = blendFactor.r;
+ blendFactor.b = blendFactor.r;
+ break;
+ case Context::BLEND_CONSTANT:
+ blendFactor.r = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[0]));
+ blendFactor.g = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[1]));
+ blendFactor.b = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[2]));
+ break;
+ case Context::BLEND_INVCONSTANT:
+ blendFactor.r = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[0]));
+ blendFactor.g = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[1]));
+ blendFactor.b = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[2]));
+ break;
+ case Context::BLEND_CONSTANTALPHA:
+ blendFactor.r = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
+ blendFactor.g = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
+ blendFactor.b = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
+ break;
+ case Context::BLEND_INVCONSTANTALPHA:
+ blendFactor.r = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+ blendFactor.g = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+ blendFactor.b = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::blendFactorAlpha(Registers &r, const Color4i &blendFactor, const Color4i ¤t, const Color4i &pixel, Context::BlendFactor blendFactorAlphaActive)
+ {
+ switch(blendFactorAlphaActive)
+ {
+ case Context::BLEND_ZERO:
+ // Optimized
+ break;
+ case Context::BLEND_ONE:
+ // Optimized
+ break;
+ case Context::BLEND_SOURCE:
+ blendFactor.a = current.a;
+ break;
+ case Context::BLEND_INVSOURCE:
+ blendFactor.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.a;
+ break;
+ case Context::BLEND_DEST:
+ blendFactor.a = pixel.a;
+ break;
+ case Context::BLEND_INVDEST:
+ blendFactor.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.a;
+ break;
+ case Context::BLEND_SOURCEALPHA:
+ blendFactor.a = current.a;
+ break;
+ case Context::BLEND_INVSOURCEALPHA:
+ blendFactor.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - current.a;
+ break;
+ case Context::BLEND_DESTALPHA:
+ blendFactor.a = pixel.a;
+ break;
+ case Context::BLEND_INVDESTALPHA:
+ blendFactor.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) - pixel.a;
+ break;
+ case Context::BLEND_SRCALPHASAT:
+ blendFactor.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+ break;
+ case Context::BLEND_CONSTANT:
+ case Context::BLEND_CONSTANTALPHA:
+ blendFactor.a = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.blendConstant4W[3]));
+ break;
+ case Context::BLEND_INVCONSTANT:
+ case Context::BLEND_INVCONSTANTALPHA:
+ blendFactor.a = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Color4i ¤t, Int &x)
+ {
+ if(!state.alphaBlendActive)
+ {
+ return;
+ }
+
+ Pointer<Byte> buffer;
+
+ Color4i pixel;
+ Short4 c01;
+ Short4 c23;
+
+ // Read pixel
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_A8R8G8B8:
+ buffer = cBuffer + 4 * x;
+ c01 = *Pointer<Short4>(buffer);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ c23 = *Pointer<Short4>(buffer);
+ pixel.b = c01;
+ pixel.g = c01;
+ pixel.b = UnpackLow(As<Byte8>(pixel.b), As<Byte8>(c23));
+ pixel.g = UnpackHigh(As<Byte8>(pixel.g), As<Byte8>(c23));
+ pixel.r = pixel.b;
+ pixel.b = UnpackLow(As<Byte8>(pixel.b), As<Byte8>(pixel.g));
+ pixel.r = UnpackHigh(As<Byte8>(pixel.r), As<Byte8>(pixel.g));
+ pixel.g = pixel.b;
+ pixel.a = pixel.r;
+ pixel.r = UnpackLow(As<Byte8>(pixel.r), As<Byte8>(pixel.r));
+ pixel.g = UnpackHigh(As<Byte8>(pixel.g), As<Byte8>(pixel.g));
+ pixel.b = UnpackLow(As<Byte8>(pixel.b), As<Byte8>(pixel.b));
+ pixel.a = UnpackHigh(As<Byte8>(pixel.a), As<Byte8>(pixel.a));
+ break;
+ case FORMAT_X8R8G8B8:
+ buffer = cBuffer + 4 * x;
+ c01 = *Pointer<Short4>(buffer);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ c23 = *Pointer<Short4>(buffer);
+ pixel.b = c01;
+ pixel.g = c01;
+ pixel.b = UnpackLow(As<Byte8>(pixel.b), As<Byte8>(c23));
+ pixel.g = UnpackHigh(As<Byte8>(pixel.g), As<Byte8>(c23));
+ pixel.r = pixel.b;
+ pixel.b = UnpackLow(As<Byte8>(pixel.b), As<Byte8>(pixel.g));
+ pixel.r = UnpackHigh(As<Byte8>(pixel.r), As<Byte8>(pixel.g));
+ pixel.g = pixel.b;
+ pixel.r = UnpackLow(As<Byte8>(pixel.r), As<Byte8>(pixel.r));
+ pixel.g = UnpackHigh(As<Byte8>(pixel.g), As<Byte8>(pixel.g));
+ pixel.b = UnpackLow(As<Byte8>(pixel.b), As<Byte8>(pixel.b));
+ pixel.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+ break;
+ case FORMAT_A8G8R8B8Q:
+ UNIMPLEMENTED();
+ // pixel.b = UnpackLow(As<Byte8>(pixel.b), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+ // pixel.r = UnpackHigh(As<Byte8>(pixel.r), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+ // pixel.g = UnpackLow(As<Byte8>(pixel.g), *Pointer<Byte8>(cBuffer + 8 * x + 8));
+ // pixel.a = UnpackHigh(As<Byte8>(pixel.a), *Pointer<Byte8>(cBuffer + 8 * x + 8));
+ break;
+ case FORMAT_X8G8R8B8Q:
+ UNIMPLEMENTED();
+ // pixel.b = UnpackLow(As<Byte8>(pixel.b), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+ // pixel.r = UnpackHigh(As<Byte8>(pixel.r), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+ // pixel.g = UnpackLow(As<Byte8>(pixel.g), *Pointer<Byte8>(cBuffer + 8 * x + 8));
+ // pixel.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+ break;
+ case FORMAT_A16B16G16R16:
+ buffer = cBuffer;
+ pixel.r = *Pointer<Short4>(buffer + 8 * x);
+ pixel.g = *Pointer<Short4>(buffer + 8 * x + 8);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ pixel.b = *Pointer<Short4>(buffer + 8 * x);
+ pixel.a = *Pointer<Short4>(buffer + 8 * x + 8);
+ transpose4x4(pixel.r, pixel.g, pixel.b, pixel.a);
+ break;
+ case FORMAT_G16R16:
+ buffer = cBuffer;
+ pixel.r = *Pointer<Short4>(buffer + 4 * x);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ pixel.g = *Pointer<Short4>(buffer + 4 * x);
+ pixel.b = pixel.r;
+ pixel.r = As<Short4>(UnpackLow(pixel.r, pixel.g));
+ pixel.b = As<Short4>(UnpackHigh(pixel.b, pixel.g));
+ pixel.g = pixel.b;
+ pixel.r = As<Short4>(UnpackLow(pixel.r, pixel.b));
+ pixel.g = As<Short4>(UnpackHigh(pixel.g, pixel.b));
+ pixel.b = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+ pixel.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ if(postBlendSRGB && state.writeSRGB)
+ {
+ sRGBtoLinear16_16(r, pixel);
+ }
+
+ // Final Color = ObjectColor * SourceBlendFactor + PixelColor * DestinationBlendFactor
+ Color4i sourceFactor;
+ Color4i destFactor;
+
+ blendFactor(r, sourceFactor, current, pixel, (Context::BlendFactor)state.sourceBlendFactor);
+ blendFactor(r, destFactor, current, pixel, (Context::BlendFactor)state.destBlendFactor);
+
+ if(state.sourceBlendFactor != Context::BLEND_ONE && state.sourceBlendFactor != Context::BLEND_ZERO)
+ {
+ current.r = MulHigh(As<UShort4>(current.r), As<UShort4>(sourceFactor.r));
+ current.g = MulHigh(As<UShort4>(current.g), As<UShort4>(sourceFactor.g));
+ current.b = MulHigh(As<UShort4>(current.b), As<UShort4>(sourceFactor.b));
+ }
+
+ if(state.destBlendFactor != Context::BLEND_ONE && state.destBlendFactor != Context::BLEND_ZERO)
+ {
+ pixel.r = MulHigh(As<UShort4>(pixel.r), As<UShort4>(destFactor.r));
+ pixel.g = MulHigh(As<UShort4>(pixel.g), As<UShort4>(destFactor.g));
+ pixel.b = MulHigh(As<UShort4>(pixel.b), As<UShort4>(destFactor.b));
+ }
+
+ switch(state.blendOperation)
+ {
+ case Context::BLENDOP_ADD:
+ current.r = AddSat(As<UShort4>(current.r), As<UShort4>(pixel.r));
+ current.g = AddSat(As<UShort4>(current.g), As<UShort4>(pixel.g));
+ current.b = AddSat(As<UShort4>(current.b), As<UShort4>(pixel.b));
+ break;
+ case Context::BLENDOP_SUB:
+ current.r = SubSat(As<UShort4>(current.r), As<UShort4>(pixel.r));
+ current.g = SubSat(As<UShort4>(current.g), As<UShort4>(pixel.g));
+ current.b = SubSat(As<UShort4>(current.b), As<UShort4>(pixel.b));
+ break;
+ case Context::BLENDOP_INVSUB:
+ current.r = SubSat(As<UShort4>(pixel.r), As<UShort4>(current.r));
+ current.g = SubSat(As<UShort4>(pixel.g), As<UShort4>(current.g));
+ current.b = SubSat(As<UShort4>(pixel.b), As<UShort4>(current.b));
+ break;
+ case Context::BLENDOP_MIN:
+ current.r = Min(As<UShort4>(current.r), As<UShort4>(pixel.r));
+ current.g = Min(As<UShort4>(current.g), As<UShort4>(pixel.g));
+ current.b = Min(As<UShort4>(current.b), As<UShort4>(pixel.b));
+ break;
+ case Context::BLENDOP_MAX:
+ current.r = Max(As<UShort4>(current.r), As<UShort4>(pixel.r));
+ current.g = Max(As<UShort4>(current.g), As<UShort4>(pixel.g));
+ current.b = Max(As<UShort4>(current.b), As<UShort4>(pixel.b));
+ break;
+ case Context::BLENDOP_SOURCE:
+ // No operation
+ break;
+ case Context::BLENDOP_DEST:
+ current.r = pixel.r;
+ current.g = pixel.g;
+ current.b = pixel.b;
+ break;
+ case Context::BLENDOP_NULL:
+ current.r = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ current.g = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ current.b = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ blendFactorAlpha(r, sourceFactor, current, pixel, (Context::BlendFactor)state.sourceBlendFactorAlpha);
+ blendFactorAlpha(r, destFactor, current, pixel, (Context::BlendFactor)state.destBlendFactorAlpha);
+
+ if(state.sourceBlendFactorAlpha != Context::BLEND_ONE && state.sourceBlendFactorAlpha != Context::BLEND_ZERO)
+ {
+ current.a = MulHigh(As<UShort4>(current.a), As<UShort4>(sourceFactor.a));
+ }
+
+ if(state.destBlendFactorAlpha != Context::BLEND_ONE && state.destBlendFactorAlpha != Context::BLEND_ZERO)
+ {
+ pixel.a = MulHigh(As<UShort4>(pixel.a), As<UShort4>(destFactor.a));
+ }
+
+ switch(state.blendOperationAlpha)
+ {
+ case Context::BLENDOP_ADD:
+ current.a = AddSat(As<UShort4>(current.a), As<UShort4>(pixel.a));
+ break;
+ case Context::BLENDOP_SUB:
+ current.a = SubSat(As<UShort4>(current.a), As<UShort4>(pixel.a));
+ break;
+ case Context::BLENDOP_INVSUB:
+ current.a = SubSat(As<UShort4>(pixel.a), As<UShort4>(current.a));
+ break;
+ case Context::BLENDOP_MIN:
+ current.a = Min(As<UShort4>(current.a), As<UShort4>(pixel.a));
+ break;
+ case Context::BLENDOP_MAX:
+ current.a = Max(As<UShort4>(current.a), As<UShort4>(pixel.a));
+ break;
+ case Context::BLENDOP_SOURCE:
+ // No operation
+ break;
+ case Context::BLENDOP_DEST:
+ current.a = pixel.a;
+ break;
+ case Context::BLENDOP_NULL:
+ current.a = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &x, Color4i ¤t, Int &sMask, Int &zMask, Int &cMask)
+ {
+ if(!state.colorWriteActive(index))
+ {
+ return;
+ }
+
+ if(postBlendSRGB && state.writeSRGB)
+ {
+ linearToSRGB16_16(r, current);
+ }
+
+ if(exactColorRounding)
+ {
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_X8G8R8B8Q:
+ case FORMAT_A8G8R8B8Q:
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ {
+ current.r = current.r - As<Short4>(As<UShort4>(current.r) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
+ current.g = current.g - As<Short4>(As<UShort4>(current.g) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
+ current.b = current.b - As<Short4>(As<UShort4>(current.b) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
+ current.a = current.a - As<Short4>(As<UShort4>(current.a) >> 8) + Short4(0x0080, 0x0080, 0x0080, 0x0080);
+ }
+ break;
+ }
+ }
+
+ int rgbaWriteMask = state.colorWriteActive(index);
+ int bgraWriteMask = rgbaWriteMask & 0x0000000A | (rgbaWriteMask & 0x00000001) << 2 | (rgbaWriteMask & 0x00000004) >> 2;
+ int brgaWriteMask = rgbaWriteMask & 0x00000008 | (rgbaWriteMask & 0x00000001) << 1 | (rgbaWriteMask & 0x00000002) << 1 | (rgbaWriteMask & 0x00000004) >> 2;
+
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_X8G8R8B8Q:
+ UNIMPLEMENTED();
+ // current.r = As<Short4>(As<UShort4>(current.r) >> 8);
+ // current.g = As<Short4>(As<UShort4>(current.g) >> 8);
+ // current.b = As<Short4>(As<UShort4>(current.b) >> 8);
+
+ // current.b = As<Short4>(Pack(As<UShort4>(current.b), As<UShort4>(current.r)));
+ // current.g = As<Short4>(Pack(As<UShort4>(current.g), As<UShort4>(current.g)));
+ break;
+ case FORMAT_A8G8R8B8Q:
+ UNIMPLEMENTED();
+ // current.r = As<Short4>(As<UShort4>(current.r) >> 8);
+ // current.g = As<Short4>(As<UShort4>(current.g) >> 8);
+ // current.b = As<Short4>(As<UShort4>(current.b) >> 8);
+ // current.a = As<Short4>(As<UShort4>(current.a) >> 8);
+
+ // current.b = As<Short4>(Pack(As<UShort4>(current.b), As<UShort4>(current.r)));
+ // current.g = As<Short4>(Pack(As<UShort4>(current.g), As<UShort4>(current.a)));
+ break;
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ if(state.targetFormat[index] == FORMAT_X8R8G8B8 || rgbaWriteMask == 0x7)
+ {
+ current.r = As<Short4>(As<UShort4>(current.r) >> 8);
+ current.g = As<Short4>(As<UShort4>(current.g) >> 8);
+ current.b = As<Short4>(As<UShort4>(current.b) >> 8);
+
+ current.b = As<Short4>(Pack(As<UShort4>(current.b), As<UShort4>(current.r)));
+ current.g = As<Short4>(Pack(As<UShort4>(current.g), As<UShort4>(current.g)));
+
+ current.r = current.b;
+ current.b = UnpackLow(As<Byte8>(current.b), As<Byte8>(current.g));
+ current.r = UnpackHigh(As<Byte8>(current.r), As<Byte8>(current.g));
+ current.g = current.b;
+ current.b = As<Short4>(UnpackLow(current.b, current.r));
+ current.g = As<Short4>(UnpackHigh(current.g, current.r));
+ }
+ else
+ {
+ current.r = As<Short4>(As<UShort4>(current.r) >> 8);
+ current.g = As<Short4>(As<UShort4>(current.g) >> 8);
+ current.b = As<Short4>(As<UShort4>(current.b) >> 8);
+ current.a = As<Short4>(As<UShort4>(current.a) >> 8);
+
+ current.b = As<Short4>(Pack(As<UShort4>(current.b), As<UShort4>(current.r)));
+ current.g = As<Short4>(Pack(As<UShort4>(current.g), As<UShort4>(current.a)));
+
+ current.r = current.b;
+ current.b = UnpackLow(As<Byte8>(current.b), As<Byte8>(current.g));
+ current.r = UnpackHigh(As<Byte8>(current.r), As<Byte8>(current.g));
+ current.g = current.b;
+ current.b = As<Short4>(UnpackLow(current.b, current.r));
+ current.g = As<Short4>(UnpackHigh(current.g, current.r));
+ }
+ break;
+ case FORMAT_G16R16:
+ current.b = current.r;
+ current.r = As<Short4>(UnpackLow(current.r, current.g));
+ current.b = As<Short4>(UnpackHigh(current.b, current.g));
+ current.g = current.b;
+ break;
+ case FORMAT_A16B16G16R16:
+ transpose4x4(current.r, current.g, current.b, current.a);
+ break;
+ case FORMAT_R32F:
+ case FORMAT_G32R32F:
+ case FORMAT_A32B32G32R32F:
+ {
+ Color4f oC;
+
+ oC.r = convertUnsigned16(UShort4(current.r));
+ oC.g = convertUnsigned16(UShort4(current.g));
+ oC.b = convertUnsigned16(UShort4(current.b));
+ oC.a = convertUnsigned16(UShort4(current.a));
+
+ writeColor(r, index, cBuffer, x, oC, sMask, zMask, cMask);
+ }
+ return;
+ default:
+ ASSERT(false);
+ }
+
+ Short4 c01 = current.b;
+ Short4 c23 = current.g;
+
+ Int xMask; // Combination of all masks
+
+ if(state.depthTestActive)
+ {
+ xMask = zMask;
+ }
+ else
+ {
+ xMask = cMask;
+ }
+
+ if(state.stencilActive)
+ {
+ xMask &= sMask;
+ }
+
+ Pointer<Byte> buffer;
+ Short4 value;
+
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_A8G8R8B8Q:
+ case FORMAT_X8G8R8B8Q: // FIXME: Don't touch alpha?
+ UNIMPLEMENTED();
+ // value = *Pointer<Short4>(cBuffer + 8 * x + 0);
+
+ // if((state.targetFormat[index] == FORMAT_A8G8R8B8Q && bgraWriteMask != 0x0000000F) ||
+ // ((state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x00000007) &&
+ // (state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x0000000F))) // FIXME: Need for masking when XRGB && Fh?
+ // {
+ // Short4 masked = value;
+ // c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+ // masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+ // c01 |= masked;
+ // }
+
+ // c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD01Q) + xMask * 8);
+ // value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
+ // c01 |= value;
+ // *Pointer<Short4>(cBuffer + 8 * x + 0) = c01;
+
+ // value = *Pointer<Short4>(cBuffer + 8 * x + 8);
+
+ // if((state.targetFormat[index] == FORMAT_A8G8R8B8Q && bgraWriteMask != 0x0000000F) ||
+ // ((state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x00000007) &&
+ // (state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x0000000F))) // FIXME: Need for masking when XRGB && Fh?
+ // {
+ // Short4 masked = value;
+ // c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+ // masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+ // c23 |= masked;
+ // }
+
+ // c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD23Q) + xMask * 8);
+ // value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
+ // c23 |= value;
+ // *Pointer<Short4>(cBuffer + 8 * x + 8) = c23;
+ break;
+ case FORMAT_A8R8G8B8:
+ case FORMAT_X8R8G8B8: // FIXME: Don't touch alpha?
+ buffer = cBuffer + x * 4;
+ value = *Pointer<Short4>(buffer);
+
+ if((state.targetFormat[index] == FORMAT_A8R8G8B8 && bgraWriteMask != 0x0000000F) ||
+ ((state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x00000007) &&
+ (state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x0000000F))) // FIXME: Need for masking when XRGB && Fh?
+ {
+ Short4 masked = value;
+ c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+ c01 |= masked;
+ }
+
+ c01 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD01Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
+ c01 |= value;
+ *Pointer<Short4>(buffer) = c01;
+
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ value = *Pointer<Short4>(buffer);
+
+ if((state.targetFormat[index] == FORMAT_A8R8G8B8 && bgraWriteMask != 0x0000000F) ||
+ ((state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x00000007) &&
+ (state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x0000000F))) // FIXME: Need for masking when XRGB && Fh?
+ {
+ Short4 masked = value;
+ c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+ c23 |= masked;
+ }
+
+ c23 &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD23Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
+ c23 |= value;
+ *Pointer<Short4>(buffer) = c23;
+ break;
+ case FORMAT_G16R16:
+ buffer = cBuffer + 4 * x;
+
+ value = *Pointer<Short4>(buffer);
+
+ if((rgbaWriteMask & 0x00000003) != 0x00000003)
+ {
+ Short4 masked = value;
+ current.r &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW01Q[rgbaWriteMask & 0x3][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW01Q[rgbaWriteMask & 0x3][0]));
+ current.r |= masked;
+ }
+
+ current.r &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD01Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
+ current.r |= value;
+ *Pointer<Short4>(buffer) = current.r;
+
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+
+ value = *Pointer<Short4>(buffer);
+
+ if((rgbaWriteMask & 0x00000003) != 0x00000003)
+ {
+ Short4 masked = value;
+ current.g &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW01Q[rgbaWriteMask & 0x3][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW01Q[rgbaWriteMask & 0x3][0]));
+ current.g |= masked;
+ }
+
+ current.g &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskD23Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
+ current.g |= value;
+ *Pointer<Short4>(buffer) = current.g;
+ break;
+ case FORMAT_A16B16G16R16:
+ buffer = cBuffer + 8 * x;
+
+ {
+ value = *Pointer<Short4>(buffer);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Short4 masked = value;
+ current.r &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+ current.r |= masked;
+ }
+
+ current.r &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ0Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ0Q) + xMask * 8);
+ current.r |= value;
+ *Pointer<Short4>(buffer) = current.r;
+ }
+
+ {
+ value = *Pointer<Short4>(buffer + 8);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Short4 masked = value;
+ current.g &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+ current.g |= masked;
+ }
+
+ current.g &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ1Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ1Q) + xMask * 8);
+ current.g |= value;
+ *Pointer<Short4>(buffer + 8) = current.g;
+ }
+
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+
+ {
+ value = *Pointer<Short4>(buffer);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Short4 masked = value;
+ current.b &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+ current.b |= masked;
+ }
+
+ current.b &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ2Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ2Q) + xMask * 8);
+ current.b |= value;
+ *Pointer<Short4>(buffer) = current.b;
+ }
+
+ {
+ value = *Pointer<Short4>(buffer + 8);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Short4 masked = value;
+ current.a &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+ masked &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+ current.a |= masked;
+ }
+
+ current.a &= *Pointer<Short4>(r.constants + OFFSET(Constants,maskQ3Q) + xMask * 8);
+ value &= *Pointer<Short4>(r.constants + OFFSET(Constants,invMaskQ3Q) + xMask * 8);
+ current.a |= value;
+ *Pointer<Short4>(buffer + 8) = current.a;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::blendFactor(Registers &r, const Color4f &blendFactor, const Color4f &oC, const Color4f &pixel, Context::BlendFactor blendFactorActive)
+ {
+ switch(blendFactorActive)
+ {
+ case Context::BLEND_ZERO:
+ // Optimized
+ break;
+ case Context::BLEND_ONE:
+ // Optimized
+ break;
+ case Context::BLEND_SOURCE:
+ blendFactor.r = oC.r;
+ blendFactor.g = oC.g;
+ blendFactor.b = oC.b;
+ break;
+ case Context::BLEND_INVSOURCE:
+ blendFactor.r = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.r;
+ blendFactor.g = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.g;
+ blendFactor.b = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.b;
+ break;
+ case Context::BLEND_DEST:
+ blendFactor.r = pixel.r;
+ blendFactor.g = pixel.g;
+ blendFactor.b = pixel.b;
+ break;
+ case Context::BLEND_INVDEST:
+ blendFactor.r = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.r;
+ blendFactor.g = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.g;
+ blendFactor.b = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.b;
+ break;
+ case Context::BLEND_SOURCEALPHA:
+ blendFactor.r = oC.a;
+ blendFactor.g = oC.a;
+ blendFactor.b = oC.a;
+ break;
+ case Context::BLEND_INVSOURCEALPHA:
+ blendFactor.r = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.a;
+ blendFactor.g = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.a;
+ blendFactor.b = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.a;
+ break;
+ case Context::BLEND_DESTALPHA:
+ blendFactor.r = pixel.a;
+ blendFactor.g = pixel.a;
+ blendFactor.b = pixel.a;
+ break;
+ case Context::BLEND_INVDESTALPHA:
+ blendFactor.r = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.a;
+ blendFactor.g = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.a;
+ blendFactor.b = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.a;
+ break;
+ case Context::BLEND_SRCALPHASAT:
+ blendFactor.r = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.a;
+ blendFactor.r = Min(blendFactor.r, oC.a);
+ blendFactor.g = blendFactor.r;
+ blendFactor.b = blendFactor.r;
+ break;
+ case Context::BLEND_CONSTANT:
+ blendFactor.r = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[0]));
+ blendFactor.g = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[1]));
+ blendFactor.b = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[2]));
+ break;
+ case Context::BLEND_INVCONSTANT:
+ blendFactor.r = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[0]));
+ blendFactor.g = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[1]));
+ blendFactor.b = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[2]));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::blendFactorAlpha(Registers &r, const Color4f &blendFactor, const Color4f &oC, const Color4f &pixel, Context::BlendFactor blendFactorAlphaActive)
+ {
+ switch(blendFactorAlphaActive)
+ {
+ case Context::BLEND_ZERO:
+ // Optimized
+ break;
+ case Context::BLEND_ONE:
+ // Optimized
+ break;
+ case Context::BLEND_SOURCE:
+ blendFactor.a = oC.a;
+ break;
+ case Context::BLEND_INVSOURCE:
+ blendFactor.a = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.a;
+ break;
+ case Context::BLEND_DEST:
+ blendFactor.a = pixel.a;
+ break;
+ case Context::BLEND_INVDEST:
+ blendFactor.a = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.a;
+ break;
+ case Context::BLEND_SOURCEALPHA:
+ blendFactor.a = oC.a;
+ break;
+ case Context::BLEND_INVSOURCEALPHA:
+ blendFactor.a = Float4(1.0f, 1.0f, 1.0f, 1.0f) - oC.a;
+ break;
+ case Context::BLEND_DESTALPHA:
+ blendFactor.a = pixel.a;
+ break;
+ case Context::BLEND_INVDESTALPHA:
+ blendFactor.a = Float4(1.0f, 1.0f, 1.0f, 1.0f) - pixel.a;
+ break;
+ case Context::BLEND_SRCALPHASAT:
+ blendFactor.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case Context::BLEND_CONSTANT:
+ blendFactor.a = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.blendConstant4F[3]));
+ break;
+ case Context::BLEND_INVCONSTANT:
+ blendFactor.a = *Pointer<Float4>(r.data + OFFSET(DrawData,factor.invBlendConstant4F[3]));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Color4f &oC, Int &x)
+ {
+ if(!state.alphaBlendActive)
+ {
+ return;
+ }
+
+ Pointer<Byte> buffer;
+ Color4f pixel;
+
+ Color4i color;
+ Short4 c01;
+ Short4 c23;
+
+ // Read pixel
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_A8R8G8B8:
+ buffer = cBuffer + 4 * x;
+ c01 = *Pointer<Short4>(buffer);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ c23 = *Pointer<Short4>(buffer);
+ color.b = c01;
+ color.g = c01;
+ color.b = UnpackLow(As<Byte8>(color.b), As<Byte8>(c23));
+ color.g = UnpackHigh(As<Byte8>(color.g), As<Byte8>(c23));
+ color.r = color.b;
+ color.b = UnpackLow(As<Byte8>(color.b), As<Byte8>(color.g));
+ color.r = UnpackHigh(As<Byte8>(color.r), As<Byte8>(color.g));
+ color.g = color.b;
+ color.a = color.r;
+ color.r = UnpackLow(As<Byte8>(color.r), As<Byte8>(color.r));
+ color.g = UnpackHigh(As<Byte8>(color.g), As<Byte8>(color.g));
+ color.b = UnpackLow(As<Byte8>(color.b), As<Byte8>(color.b));
+ color.a = UnpackHigh(As<Byte8>(color.a), As<Byte8>(color.a));
+
+ pixel.r = convertUnsigned16(As<UShort4>(color.r));
+ pixel.g = convertUnsigned16(As<UShort4>(color.g));
+ pixel.b = convertUnsigned16(As<UShort4>(color.b));
+ pixel.a = convertUnsigned16(As<UShort4>(color.a));
+ break;
+ case FORMAT_X8R8G8B8:
+ buffer = cBuffer + 4 * x;
+ c01 = *Pointer<Short4>(buffer);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ c23 = *Pointer<Short4>(buffer);
+ color.b = c01;
+ color.g = c01;
+ color.b = UnpackLow(As<Byte8>(color.b), As<Byte8>(c23));
+ color.g = UnpackHigh(As<Byte8>(color.g), As<Byte8>(c23));
+ color.r = color.b;
+ color.b = UnpackLow(As<Byte8>(color.b), As<Byte8>(color.g));
+ color.r = UnpackHigh(As<Byte8>(color.r), As<Byte8>(color.g));
+ color.g = color.b;
+ color.r = UnpackLow(As<Byte8>(color.r), As<Byte8>(color.r));
+ color.g = UnpackHigh(As<Byte8>(color.g), As<Byte8>(color.g));
+ color.b = UnpackLow(As<Byte8>(color.b), As<Byte8>(color.b));
+
+ pixel.r = convertUnsigned16(As<UShort4>(color.r));
+ pixel.g = convertUnsigned16(As<UShort4>(color.g));
+ pixel.b = convertUnsigned16(As<UShort4>(color.b));
+ pixel.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case FORMAT_A8G8R8B8Q:
+UNIMPLEMENTED();
+ // UnpackLow(pixel.b, qword_ptr [cBuffer+8*x+0]);
+ // UnpackHigh(pixel.r, qword_ptr [cBuffer+8*x+0]);
+ // UnpackLow(pixel.g, qword_ptr [cBuffer+8*x+8]);
+ // UnpackHigh(pixel.a, qword_ptr [cBuffer+8*x+8]);
+ break;
+ case FORMAT_X8G8R8B8Q:
+UNIMPLEMENTED();
+ // UnpackLow(pixel.b, qword_ptr [cBuffer+8*x+0]);
+ // UnpackHigh(pixel.r, qword_ptr [cBuffer+8*x+0]);
+ // UnpackLow(pixel.g, qword_ptr [cBuffer+8*x+8]);
+ // pixel.a = Short4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+ break;
+ case FORMAT_A16B16G16R16:
+ buffer = cBuffer;
+ color.r = *Pointer<Short4>(buffer + 8 * x);
+ color.g = *Pointer<Short4>(buffer + 8 * x + 8);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ color.b = *Pointer<Short4>(buffer + 8 * x);
+ color.a = *Pointer<Short4>(buffer + 8 * x + 8);
+
+ transpose4x4(color.r, color.g, color.b, color.a);
+
+ pixel.r = convertUnsigned16(As<UShort4>(color.r));
+ pixel.g = convertUnsigned16(As<UShort4>(color.g));
+ pixel.b = convertUnsigned16(As<UShort4>(color.b));
+ pixel.a = convertUnsigned16(As<UShort4>(color.a));
+ break;
+ case FORMAT_G16R16:
+ buffer = cBuffer;
+ color.r = *Pointer<Short4>(buffer + 4 * x);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ color.g = *Pointer<Short4>(buffer + 4 * x);
+ color.b = color.r;
+ color.r = As<Short4>(UnpackLow(color.r, color.g));
+ color.b = As<Short4>(UnpackHigh(color.b, color.g));
+ color.g = color.b;
+ color.r = As<Short4>(UnpackLow(color.r, color.b));
+ color.g = As<Short4>(UnpackHigh(color.g, color.b));
+
+ pixel.r = convertUnsigned16(As<UShort4>(color.r));
+ pixel.g = convertUnsigned16(As<UShort4>(color.g));
+ pixel.b = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ pixel.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case FORMAT_R32F:
+ buffer = cBuffer;
+ // FIXME: movlps
+ pixel.r.x = *Pointer<Float>(buffer + 4 * x + 0);
+ pixel.r.y = *Pointer<Float>(buffer + 4 * x + 4);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ // FIXME: movhps
+ pixel.r.z = *Pointer<Float>(buffer + 4 * x + 0);
+ pixel.r.w = *Pointer<Float>(buffer + 4 * x + 4);
+ pixel.g = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ pixel.b = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ pixel.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case FORMAT_G32R32F:
+ buffer = cBuffer;
+ pixel.r = *Pointer<Float4>(buffer + 8 * x, 16);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ pixel.g = *Pointer<Float4>(buffer + 8 * x, 16);
+ pixel.b = pixel.r;
+ pixel.r = ShuffleLowHigh(pixel.r, pixel.g, 0x88);
+ pixel.b = ShuffleLowHigh(pixel.b, pixel.g, 0xDD);
+ pixel.g = pixel.b;
+ pixel.b = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ pixel.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case FORMAT_A32B32G32R32F:
+ buffer = cBuffer;
+ pixel.r = *Pointer<Float4>(buffer + 16 * x, 16);
+ pixel.g = *Pointer<Float4>(buffer + 16 * x + 16, 16);
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+ pixel.b = *Pointer<Float4>(buffer + 16 * x, 16);
+ pixel.a = *Pointer<Float4>(buffer + 16 * x + 16, 16);
+ transpose4x4(pixel.r, pixel.g, pixel.b, pixel.a);
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ if(postBlendSRGB && state.writeSRGB)
+ {
+ sRGBtoLinear(pixel.r);
+ sRGBtoLinear(pixel.g);
+ sRGBtoLinear(pixel.b);
+ }
+
+ // Final Color = ObjectColor * SourceBlendFactor + PixelColor * DestinationBlendFactor
+ Color4f sourceFactor;
+ Color4f destFactor;
+
+ blendFactor(r, sourceFactor, oC, pixel, (Context::BlendFactor)state.sourceBlendFactor);
+ blendFactor(r, destFactor, oC, pixel, (Context::BlendFactor)state.destBlendFactor);
+
+ if(state.sourceBlendFactor != Context::BLEND_ONE && state.sourceBlendFactor != Context::BLEND_ZERO)
+ {
+ oC.r *= sourceFactor.r;
+ oC.g *= sourceFactor.g;
+ oC.b *= sourceFactor.b;
+ }
+
+ if(state.destBlendFactor != Context::BLEND_ONE && state.destBlendFactor != Context::BLEND_ZERO)
+ {
+ pixel.r *= destFactor.r;
+ pixel.g *= destFactor.g;
+ pixel.b *= destFactor.b;
+ }
+
+ switch(state.blendOperation)
+ {
+ case Context::BLENDOP_ADD:
+ oC.r += pixel.r;
+ oC.g += pixel.g;
+ oC.b += pixel.b;
+ break;
+ case Context::BLENDOP_SUB:
+ oC.r -= pixel.r;
+ oC.g -= pixel.g;
+ oC.b -= pixel.b;
+ break;
+ case Context::BLENDOP_INVSUB:
+ oC.r = pixel.r - oC.r;
+ oC.g = pixel.g - oC.g;
+ oC.b = pixel.b - oC.b;
+ break;
+ case Context::BLENDOP_MIN:
+ oC.r = Min(oC.r, pixel.r);
+ oC.g = Min(oC.g, pixel.g);
+ oC.b = Min(oC.b, pixel.b);
+ break;
+ case Context::BLENDOP_MAX:
+ oC.r = Max(oC.r, pixel.r);
+ oC.g = Max(oC.g, pixel.g);
+ oC.b = Max(oC.b, pixel.b);
+ break;
+ case Context::BLENDOP_SOURCE:
+ // No operation
+ break;
+ case Context::BLENDOP_DEST:
+ oC.r = pixel.r;
+ oC.g = pixel.g;
+ oC.b = pixel.b;
+ break;
+ case Context::BLENDOP_NULL:
+ oC.r = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ oC.g = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ oC.b = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ blendFactorAlpha(r, sourceFactor, oC, pixel, (Context::BlendFactor)state.sourceBlendFactorAlpha);
+ blendFactorAlpha(r, destFactor, oC, pixel, (Context::BlendFactor)state.destBlendFactorAlpha);
+
+ if(state.sourceBlendFactorAlpha != Context::BLEND_ONE && state.sourceBlendFactorAlpha != Context::BLEND_ZERO)
+ {
+ oC.a *= sourceFactor.a;
+ }
+
+ if(state.destBlendFactorAlpha != Context::BLEND_ONE && state.destBlendFactorAlpha != Context::BLEND_ZERO)
+ {
+ pixel.a *= destFactor.a;
+ }
+
+ switch(state.blendOperationAlpha)
+ {
+ case Context::BLENDOP_ADD:
+ oC.a += pixel.a;
+ break;
+ case Context::BLENDOP_SUB:
+ oC.a -= pixel.a;
+ break;
+ case Context::BLENDOP_INVSUB:
+ pixel.a -= oC.a;
+ oC.a = pixel.a;
+ break;
+ case Context::BLENDOP_MIN:
+ oC.a = Min(oC.a, pixel.a);
+ break;
+ case Context::BLENDOP_MAX:
+ oC.a = Max(oC.a, pixel.a);
+ break;
+ case Context::BLENDOP_SOURCE:
+ // No operation
+ break;
+ case Context::BLENDOP_DEST:
+ oC.a = pixel.a;
+ break;
+ case Context::BLENDOP_NULL:
+ oC.a = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &x, Color4f &oC, Int &sMask, Int &zMask, Int &cMask)
+ {
+ if(!state.colorWriteActive(index))
+ {
+ return;
+ }
+
+ Color4i color;
+
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ case FORMAT_G16R16:
+ case FORMAT_A16B16G16R16:
+ convertFixed16(color, oC, true);
+ writeColor(r, index, cBuffer, x, color, sMask, zMask, cMask);
+ return;
+ case FORMAT_R32F:
+ break;
+ case FORMAT_G32R32F:
+ oC.b = oC.r;
+ oC.r = UnpackLow(oC.r, oC.g);
+ oC.b = UnpackHigh(oC.b, oC.g);
+ oC.g = oC.b;
+ break;
+ case FORMAT_A32B32G32R32F:
+ transpose4x4(oC.r, oC.g, oC.b, oC.a);
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ int rgbaWriteMask = state.colorWriteActive(index);
+
+ Int xMask; // Combination of all masks
+
+ if(state.depthTestActive)
+ {
+ xMask = zMask;
+ }
+ else
+ {
+ xMask = cMask;
+ }
+
+ if(state.stencilActive)
+ {
+ xMask &= sMask;
+ }
+
+ Pointer<Byte> buffer;
+ Float4 value;
+
+ switch(state.targetFormat[index])
+ {
+ case FORMAT_R32F:
+ if(rgbaWriteMask & 0x00000001)
+ {
+ buffer = cBuffer + 4 * x;
+
+ // FIXME: movlps
+ value.x = *Pointer<Float>(buffer + 0);
+ value.y = *Pointer<Float>(buffer + 4);
+
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+
+ // FIXME: movhps
+ value.z = *Pointer<Float>(buffer + 0);
+ value.w = *Pointer<Float>(buffer + 4);
+
+ oC.r = As<Float4>(As<Int4>(oC.r) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X) + xMask * 16, 16));
+ value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X) + xMask * 16, 16));
+ oC.r = As<Float4>(As<Int4>(oC.r) | As<Int4>(value));
+
+ // FIXME: movhps
+ *Pointer<Float>(buffer + 0) = oC.r.z;
+ *Pointer<Float>(buffer + 4) = oC.r.w;
+
+ buffer -= *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+
+ // FIXME: movlps
+ *Pointer<Float>(buffer + 0) = oC.r.x;
+ *Pointer<Float>(buffer + 4) = oC.r.y;
+ }
+ break;
+ case FORMAT_G32R32F:
+ buffer = cBuffer + 8 * x;
+
+ value = *Pointer<Float4>(buffer);
+
+ if((rgbaWriteMask & 0x00000003) != 0x00000003)
+ {
+ Float4 masked = value;
+ oC.r = As<Float4>(As<Int4>(oC.r) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD01X[rgbaWriteMask & 0x3][0])));
+ masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD01X[rgbaWriteMask & 0x3][0])));
+ oC.r = As<Float4>(As<Int4>(oC.r) | As<Int4>(masked));
+ }
+
+ oC.r = As<Float4>(As<Int4>(oC.r) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskQ01X) + xMask * 16, 16));
+ value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskQ01X) + xMask * 16, 16));
+ oC.r = As<Float4>(As<Int4>(oC.r) | As<Int4>(value));
+ *Pointer<Float4>(buffer) = oC.r;
+
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+
+ value = *Pointer<Float4>(buffer);
+
+ if((rgbaWriteMask & 0x00000003) != 0x00000003)
+ {
+ Float4 masked;
+
+ masked = value;
+ oC.g = As<Float4>(As<Int4>(oC.g) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD01X[rgbaWriteMask & 0x3][0])));
+ masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD01X[rgbaWriteMask & 0x3][0])));
+ oC.g = As<Float4>(As<Int4>(oC.g) | As<Int4>(masked));
+ }
+
+ oC.g = As<Float4>(As<Int4>(oC.g) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskQ23X) + xMask * 16, 16));
+ value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskQ23X) + xMask * 16, 16));
+ oC.g = As<Float4>(As<Int4>(oC.g) | As<Int4>(value));
+ *Pointer<Float4>(buffer) = oC.g;
+ break;
+ case FORMAT_A32B32G32R32F:
+ buffer = cBuffer + 16 * x;
+
+ {
+ value = *Pointer<Float4>(buffer, 16);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Float4 masked = value;
+ oC.r = As<Float4>(As<Int4>(oC.r) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+ masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+ oC.r = As<Float4>(As<Int4>(oC.r) | As<Int4>(masked));
+ }
+
+ oC.r = As<Float4>(As<Int4>(oC.r) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX0X) + xMask * 16, 16));
+ value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX0X) + xMask * 16, 16));
+ oC.r = As<Float4>(As<Int4>(oC.r) | As<Int4>(value));
+ *Pointer<Float4>(buffer, 16) = oC.r;
+ }
+
+ {
+ value = *Pointer<Float4>(buffer + 16, 16);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Float4 masked = value;
+ oC.g = As<Float4>(As<Int4>(oC.g) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+ masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+ oC.g = As<Float4>(As<Int4>(oC.g) | As<Int4>(masked));
+ }
+
+ oC.g = As<Float4>(As<Int4>(oC.g) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX1X) + xMask * 16, 16));
+ value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX1X) + xMask * 16, 16));
+ oC.g = As<Float4>(As<Int4>(oC.g) | As<Int4>(value));
+ *Pointer<Float4>(buffer + 16, 16) = oC.g;
+ }
+
+ buffer += *Pointer<Int>(r.data + OFFSET(DrawData,colorPitchB[index]));
+
+ {
+ value = *Pointer<Float4>(buffer, 16);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Float4 masked = value;
+ oC.b = As<Float4>(As<Int4>(oC.b) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+ masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+ oC.b = As<Float4>(As<Int4>(oC.b) | As<Int4>(masked));
+ }
+
+ oC.b = As<Float4>(As<Int4>(oC.b) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX2X) + xMask * 16, 16));
+ value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX2X) + xMask * 16, 16));
+ oC.b = As<Float4>(As<Int4>(oC.b) | As<Int4>(value));
+ *Pointer<Float4>(buffer, 16) = oC.b;
+ }
+
+ {
+ value = *Pointer<Float4>(buffer + 16, 16);
+
+ if(rgbaWriteMask != 0x0000000F)
+ {
+ Float4 masked = value;
+ oC.a = As<Float4>(As<Int4>(oC.a) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+ masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+ oC.a = As<Float4>(As<Int4>(oC.a) | As<Int4>(masked));
+ }
+
+ oC.a = As<Float4>(As<Int4>(oC.a) & *Pointer<Int4>(r.constants + OFFSET(Constants,maskX3X) + xMask * 16, 16));
+ value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(r.constants + OFFSET(Constants,invMaskX3X) + xMask * 16, 16));
+ oC.a = As<Float4>(As<Int4>(oC.a) | As<Int4>(value));
+ *Pointer<Float4>(buffer + 16, 16) = oC.a;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::ps_1_x(Registers &r, Int cMask[4])
+ {
+ int pad = 0; // Count number of texm3x3pad instructions
+ Color4i dPairing; // Destination for first pairing instruction
+
+ for(int i = 0; i < pixelShader->getLength(); i++)
+ {
+ const ShaderInstruction *instruction = pixelShader->getInstruction(i);
+ Op::Opcode opcode = instruction->getOpcode();
+
+ // #ifndef NDEBUG // FIXME: Centralize debug output control
+ // pixelShader->printInstruction(i, "debug.txt");
+ // #endif
+
+ if(opcode == Op::OPCODE_DCL || opcode == Op::OPCODE_DEF || opcode == Op::OPCODE_DEFI || opcode == Op::OPCODE_DEFB)
+ {
+ continue;
+ }
+
+ const Dst &dst = instruction->getDestinationParameter();
+ const Src &src0 = instruction->getSourceParameter(0);
+ const Src &src1 = instruction->getSourceParameter(1);
+ const Src &src2 = instruction->getSourceParameter(2);
+ const Src &src3 = instruction->getSourceParameter(3);
+
+ bool pairing = i + 1 < pixelShader->getLength() && pixelShader->getInstruction(i + 1)->isCoissue(); // First instruction of pair
+ bool coissue = instruction->isCoissue(); // Second instruction of pair
+
+ Color4i d;
+ Color4i s0;
+ Color4i s1;
+ Color4i s2;
+ Color4i s3;
+
+ if(src0.type != Src::PARAMETER_VOID) s0 = regi(r, src0);
+ if(src1.type != Src::PARAMETER_VOID) s1 = regi(r, src1);
+ if(src2.type != Src::PARAMETER_VOID) s2 = regi(r, src2);
+ if(src3.type != Src::PARAMETER_VOID) s3 = regi(r, src3);
+
+ switch(opcode)
+ {
+ case Op::OPCODE_PS_1_0: break;
+ case Op::OPCODE_PS_1_1: break;
+ case Op::OPCODE_PS_1_2: break;
+ case Op::OPCODE_PS_1_3: break;
+ case Op::OPCODE_PS_1_4: break;
+
+ case Op::OPCODE_DEF: break;
+
+ case Op::OPCODE_NOP: break;
+ case Op::OPCODE_MOV: MOV(d, s0); break;
+ case Op::OPCODE_ADD: ADD(d, s0, s1); break;
+ case Op::OPCODE_SUB: SUB(d, s0, s1); break;
+ case Op::OPCODE_MAD: MAD(d, s0, s1, s2); break;
+ case Op::OPCODE_MUL: MUL(d, s0, s1); break;
+ case Op::OPCODE_DP3: DP3(d, s0, s1); break;
+ case Op::OPCODE_DP4: DP4(d, s0, s1); break;
+ case Op::OPCODE_LRP: LRP(d, s0, s1, s2); break;
+ case Op::OPCODE_TEXCOORD:
+ if(pixelShader->getVersion() < 0x0104)
+ {
+ TEXCOORD(d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index);
+ }
+ else
+ {
+ if((src0.swizzle & 0x30) == 0x20) // .xyz
+ {
+ TEXCRD(d, Float4(r.vx[2 + src0.index]), Float4(r.vy[2 + src0.index]), Float4(r.vz[2 + src0.index]), src0.index, src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DZ || src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DW);
+ }
+ else // .xyw
+ {
+ TEXCRD(d, Float4(r.vx[2 + src0.index]), Float4(r.vy[2 + src0.index]), Float4(r.vw[2 + src0.index]), src0.index, src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DZ || src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DW);
+ }
+ }
+ break;
+ case Op::OPCODE_TEXKILL:
+ if(pixelShader->getVersion() < 0x0104)
+ {
+ TEXKILL(cMask, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]));
+ }
+ else if(pixelShader->getVersion() == 0x0104)
+ {
+ if(dst.type == Dst::PARAMETER_TEXTURE)
+ {
+ TEXKILL(cMask, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]));
+ }
+ else
+ {
+ TEXKILL(cMask, r.ri[dst.index]);
+ }
+ }
+ else ASSERT(false);
+ break;
+ case Op::OPCODE_TEX:
+ if(pixelShader->getVersion() < 0x0104)
+ {
+ TEX(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index, false);
+ }
+ else if(pixelShader->getVersion() == 0x0104)
+ {
+ if(src0.type == Src::PARAMETER_TEXTURE)
+ {
+ if((src0.swizzle & 0x30) == 0x20) // .xyz
+ {
+ TEX(r, d, Float4(r.vx[2 + src0.index]), Float4(r.vy[2 + src0.index]), Float4(r.vz[2 + src0.index]), dst.index, src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DZ || src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DW);
+ }
+ else // .xyw
+ {
+ TEX(r, d, Float4(r.vx[2 + src0.index]), Float4(r.vy[2 + src0.index]), Float4(r.vw[2 + src0.index]), dst.index, src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DZ || src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DW);
+ }
+ }
+ else
+ {
+ TEXLD(r, d, s0, dst.index, src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DZ || src0.modifier == ShaderInstruction::SourceParameter::MODIFIER_DW);
+ }
+ }
+ else ASSERT(false);
+ break;
+ case Op::OPCODE_TEXBEM: TEXBEM(r, d, s0, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index); break;
+ case Op::OPCODE_TEXBEML: TEXBEML(r, d, s0, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index); break;
+ case Op::OPCODE_TEXREG2AR: TEXREG2AR(r, d, s0, dst.index); break;
+ case Op::OPCODE_TEXREG2GB: TEXREG2GB(r, d, s0, dst.index); break;
+ case Op::OPCODE_TEXM3X2PAD: TEXM3X2PAD(r, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), s0, 0, src0.modifier == Src::MODIFIER_SIGN); break;
+ case Op::OPCODE_TEXM3X2TEX: TEXM3X2TEX(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index, s0, src0.modifier == Src::MODIFIER_SIGN); break;
+ case Op::OPCODE_TEXM3X3PAD: TEXM3X3PAD(r, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), s0, pad++ % 2, src0.modifier == Src::MODIFIER_SIGN); break;
+ case Op::OPCODE_TEXM3X3TEX: TEXM3X3TEX(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index, s0, src0.modifier == Src::MODIFIER_SIGN); break;
+ case Op::OPCODE_TEXM3X3SPEC: TEXM3X3SPEC(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index, s0, s1); break;
+ case Op::OPCODE_TEXM3X3VSPEC: TEXM3X3VSPEC(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index, s0); break;
+ case Op::OPCODE_CND: CND(d, s0, s1, s2); break;
+ case Op::OPCODE_TEXREG2RGB: TEXREG2RGB(r, d, s0, dst.index); break;
+ case Op::OPCODE_TEXDP3TEX: TEXDP3TEX(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), dst.index, s0); break;
+ case Op::OPCODE_TEXM3X2DEPTH: TEXM3X2DEPTH(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), s0, src0.modifier == Src::MODIFIER_SIGN); break;
+ case Op::OPCODE_TEXDP3: TEXDP3(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), s0); break;
+ case Op::OPCODE_TEXM3X3: TEXM3X3(r, d, Float4(r.vx[2 + dst.index]), Float4(r.vy[2 + dst.index]), Float4(r.vz[2 + dst.index]), s0, src0.modifier == Src::MODIFIER_SIGN); break;
+ case Op::OPCODE_TEXDEPTH: TEXDEPTH(r); break;
+ case Op::OPCODE_CMP: CMP(d, s0, s1, s2); break;
+ case Op::OPCODE_BEM: BEM(r, d, s0, s1, dst.index); break;
+ case Op::OPCODE_PHASE: break;
+ case Op::OPCODE_END: break;
+ default:
+ ASSERT(false);
+ }
+
+ if(dst.type != Dst::PARAMETER_VOID && opcode != Op::OPCODE_TEXKILL)
+ {
+ if(dst.shift > 0)
+ {
+ if(dst.mask & 0x1) {d.r = AddSat(d.r, d.r); if(dst.shift > 1) d.r = AddSat(d.r, d.r); if(dst.shift > 2) d.r = AddSat(d.r, d.r);}
+ if(dst.mask & 0x2) {d.g = AddSat(d.g, d.g); if(dst.shift > 1) d.g = AddSat(d.g, d.g); if(dst.shift > 2) d.g = AddSat(d.g, d.g);}
+ if(dst.mask & 0x4) {d.b = AddSat(d.b, d.b); if(dst.shift > 1) d.b = AddSat(d.b, d.b); if(dst.shift > 2) d.b = AddSat(d.b, d.b);}
+ if(dst.mask & 0x8) {d.a = AddSat(d.a, d.a); if(dst.shift > 1) d.a = AddSat(d.a, d.a); if(dst.shift > 2) d.a = AddSat(d.a, d.a);}
+ }
+ else if(dst.shift < 0)
+ {
+ if(dst.mask & 0x1) d.r = d.r >> -dst.shift;
+ if(dst.mask & 0x2) d.g = d.g >> -dst.shift;
+ if(dst.mask & 0x4) d.b = d.b >> -dst.shift;
+ if(dst.mask & 0x8) d.a = d.a >> -dst.shift;
+ }
+
+ if(dst.saturate)
+ {
+ if(dst.mask & 0x1) {d.r = Min(d.r, Short4(0x1000, 0x1000, 0x1000, 0x1000)); d.r = Max(d.r, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
+ if(dst.mask & 0x2) {d.g = Min(d.g, Short4(0x1000, 0x1000, 0x1000, 0x1000)); d.g = Max(d.g, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
+ if(dst.mask & 0x4) {d.b = Min(d.b, Short4(0x1000, 0x1000, 0x1000, 0x1000)); d.b = Max(d.b, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
+ if(dst.mask & 0x8) {d.a = Min(d.a, Short4(0x1000, 0x1000, 0x1000, 0x1000)); d.a = Max(d.a, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
+ }
+
+ if(pairing)
+ {
+ if(dst.mask & 0x1) dPairing.r = d.r;
+ if(dst.mask & 0x2) dPairing.g = d.g;
+ if(dst.mask & 0x4) dPairing.b = d.b;
+ if(dst.mask & 0x8) dPairing.a = d.a;
+ }
+
+ if(coissue)
+ {
+ const Dst &dst = pixelShader->getInstruction(i - 1)->getDestinationParameter();
+
+ writeDestination(r, dPairing, dst);
+ }
+
+ if(!pairing)
+ {
+ writeDestination(r, d, dst);
+ }
+ }
+ }
+ }
+
+ void PixelRoutine::ps_2_x(Registers &r, Int cMask[4])
+ {
+ r.enableIndex = 0;
+ r.stackIndex = 0;
+
+ for(int i = 0; i < pixelShader->getLength(); i++)
+ {
+ const ShaderInstruction *instruction = pixelShader->getInstruction(i);
+ Op::Opcode opcode = instruction->getOpcode();
+
+ // #ifndef NDEBUG // FIXME: Centralize debug output control
+ // pixelShader->printInstruction(i, "debug.txt");
+ // #endif
+
+ if(opcode == Op::OPCODE_DCL || opcode == Op::OPCODE_DEF || opcode == Op::OPCODE_DEFI || opcode == Op::OPCODE_DEFB)
+ {
+ continue;
+ }
+
+ const Dst &dst = instruction->getDestinationParameter();
+ const Src &src0 = instruction->getSourceParameter(0);
+ const Src &src1 = instruction->getSourceParameter(1);
+ const Src &src2 = instruction->getSourceParameter(2);
+ const Src &src3 = instruction->getSourceParameter(3);
+
+ bool predicate = instruction->isPredicate();
+ Control control = instruction->getControl();
+ bool pp = dst.partialPrecision;
+ bool project = instruction->isProject();
+ bool bias = instruction->isBias();
+
+ Color4f d;
+ Color4f s0;
+ Color4f s1;
+ Color4f s2;
+ Color4f s3;
+
+ if(opcode == Op::OPCODE_TEXKILL)
+ {
+ if(dst.type == Dst::PARAMETER_TEXTURE)
+ {
+ d.x = r.vx[2 + dst.index];
+ d.y = r.vy[2 + dst.index];
+ d.z = r.vz[2 + dst.index];
+ d.w = r.vw[2 + dst.index];
+ }
+ else
+ {
+ d = r.rf[dst.index];
+ }
+ }
+
+ if(src0.type != Src::PARAMETER_VOID) s0 = reg(r, src0);
+ if(src1.type != Src::PARAMETER_VOID) s1 = reg(r, src1);
+ if(src2.type != Src::PARAMETER_VOID) s2 = reg(r, src2);
+ if(src3.type != Src::PARAMETER_VOID) s3 = reg(r, src3);
+
+ switch(opcode)
+ {
+ case Op::OPCODE_PS_2_0: break;
+ case Op::OPCODE_PS_2_x: break;
+ case Op::OPCODE_PS_3_0: break;
+ case Op::OPCODE_DEF: break;
+ case Op::OPCODE_DCL: break;
+ case Op::OPCODE_NOP: break;
+ case Op::OPCODE_MOV: mov(d, s0); break;
+ case Op::OPCODE_ADD: add(d, s0, s1); break;
+ case Op::OPCODE_SUB: sub(d, s0, s1); break;
+ case Op::OPCODE_MUL: mul(d, s0, s1); break;
+ case Op::OPCODE_MAD: mad(d, s0, s1, s2); break;
+ case Op::OPCODE_DP2ADD: dp2add(d, s0, s1, s2); break;
+ case Op::OPCODE_DP3: dp3(d, s0, s1); break;
+ case Op::OPCODE_DP4: dp4(d, s0, s1); break;
+ case Op::OPCODE_CMP: cmp(d, s0, s1, s2); break;
+ case Op::OPCODE_FRC: frc(d, s0); break;
+ case Op::OPCODE_EXP: exp(d, s0, pp); break;
+ case Op::OPCODE_LOG: log(d, s0, pp); break;
+ case Op::OPCODE_RCP: rcp(d, s0, pp); break;
+ case Op::OPCODE_RSQ: rsq(d, s0, pp); break;
+ case Op::OPCODE_MIN: min(d, s0, s1); break;
+ case Op::OPCODE_MAX: max(d, s0, s1); break;
+ case Op::OPCODE_LRP: lrp(d, s0, s1, s2); break;
+ case Op::OPCODE_POW: pow(d, s0, s1, pp); break;
+ case Op::OPCODE_CRS: crs(d, s0, s1); break;
+ case Op::OPCODE_NRM: nrm(d, s0, pp); break;
+ case Op::OPCODE_ABS: abs(d, s0); break;
+ case Op::OPCODE_SINCOS: sincos(d, s0, pp); break;
+ case Op::OPCODE_M4X4: M4X4(r, d, s0, src1); break;
+ case Op::OPCODE_M4X3: M4X3(r, d, s0, src1); break;
+ case Op::OPCODE_M3X4: M3X4(r, d, s0, src1); break;
+ case Op::OPCODE_M3X3: M3X3(r, d, s0, src1); break;
+ case Op::OPCODE_M3X2: M3X2(r, d, s0, src1); break;
+ case Op::OPCODE_TEX: TEXLD(r, d, s0, src1, project, bias); break;
+ case Op::OPCODE_TEXLDD: TEXLDD(r, d, s0, src1, s2, s3, project, bias); break;
+ case Op::OPCODE_TEXLDL: TEXLDL(r, d, s0, src1, project, bias); break;
+ case Op::OPCODE_TEXKILL: TEXKILL(cMask, d, dst.mask); break;
+ case Op::OPCODE_DSX: DSX(d, s0); break;
+ case Op::OPCODE_DSY: DSY(d, s0); break;
+ case Op::OPCODE_BREAK: BREAK(r); break;
+ case Op::OPCODE_BREAKC: BREAKC(r, s0, s1, control); break;
+ case Op::OPCODE_BREAKP: BREAKP(r, src0); break;
+ case Op::OPCODE_CALL: CALL(r, dst.index); break;
+ case Op::OPCODE_CALLNZ: CALLNZ(r, dst.index, src0); break;
+ case Op::OPCODE_ELSE: ELSE(r); break;
+ case Op::OPCODE_ENDIF: ENDIF(r); break;
+ case Op::OPCODE_ENDLOOP: ENDLOOP(r); break;
+ case Op::OPCODE_ENDREP: ENDREP(r); break;
+ case Op::OPCODE_IF: IF(r, src0); break;
+ case Op::OPCODE_IFC: IFC(r, s0, s1, control); break;
+ case Op::OPCODE_LABEL: LABEL(dst.index); break;
+ case Op::OPCODE_LOOP: LOOP(r, src1); break;
+ case Op::OPCODE_REP: REP(r, src0); break;
+ case Op::OPCODE_RET: RET(r); break;
+ case Op::OPCODE_SETP: setp(d, s0, s1, control); break;
+ case Op::OPCODE_END: break;
+ default:
+ ASSERT(false);
+ }
+
+ if(dst.type != Dst::PARAMETER_VOID && dst.type != Dst::PARAMETER_LABEL && opcode != Op::OPCODE_TEXKILL)
+ {
+ if(dst.saturate)
+ {
+ if(dst.x) d.r = Max(d.r, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ if(dst.y) d.g = Max(d.g, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ if(dst.z) d.b = Max(d.b, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ if(dst.w) d.a = Max(d.a, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+
+ if(dst.x) d.r = Min(d.r, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ if(dst.y) d.g = Min(d.g, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ if(dst.z) d.b = Min(d.b, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ if(dst.w) d.a = Min(d.a, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ }
+
+ if(pixelShader->containsDynamicBranching())
+ {
+ Color4f pDst; // FIXME: Rename
+
+ switch(dst.type)
+ {
+ case Dst::PARAMETER_TEMP:
+ if(dst.x) pDst.x = r.rf[dst.index].x;
+ if(dst.y) pDst.y = r.rf[dst.index].y;
+ if(dst.z) pDst.z = r.rf[dst.index].z;
+ if(dst.w) pDst.w = r.rf[dst.index].w;
+ break;
+ case Dst::PARAMETER_COLOROUT:
+ if(dst.x) pDst.x = r.oC[dst.index].x;
+ if(dst.y) pDst.y = r.oC[dst.index].y;
+ if(dst.z) pDst.z = r.oC[dst.index].z;
+ if(dst.w) pDst.w = r.oC[dst.index].w;
+ break;
+ case Dst::PARAMETER_PREDICATE:
+ if(dst.x) pDst.x = r.p0.x;
+ if(dst.y) pDst.y = r.p0.y;
+ if(dst.z) pDst.z = r.p0.z;
+ if(dst.w) pDst.w = r.p0.w;
+ break;
+ case Dst::PARAMETER_DEPTHOUT:
+ pDst.x = r.oDepth;
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ Int4 enable = r.enableStack[r.enableIndex] & r.enableBreak;
+
+ Int4 xEnable = enable;
+ Int4 yEnable = enable;
+ Int4 zEnable = enable;
+ Int4 wEnable = enable;
+
+ if(predicate)
+ {
+ unsigned char pSwizzle = instruction->getPredicateSwizzle();
+
+ Float4 xPredicate = r.p0[(pSwizzle >> 0) & 0x03];
+ Float4 yPredicate = r.p0[(pSwizzle >> 2) & 0x03];
+ Float4 zPredicate = r.p0[(pSwizzle >> 4) & 0x03];
+ Float4 wPredicate = r.p0[(pSwizzle >> 6) & 0x03];
+
+ if(!instruction->isPredicateNot())
+ {
+ if(dst.x) xEnable = xEnable & As<Int4>(xPredicate);
+ if(dst.y) yEnable = yEnable & As<Int4>(yPredicate);
+ if(dst.z) zEnable = zEnable & As<Int4>(zPredicate);
+ if(dst.w) wEnable = wEnable & As<Int4>(wPredicate);
+ }
+ else
+ {
+ if(dst.x) xEnable = xEnable & ~As<Int4>(xPredicate);
+ if(dst.y) yEnable = yEnable & ~As<Int4>(yPredicate);
+ if(dst.z) zEnable = zEnable & ~As<Int4>(zPredicate);
+ if(dst.w) wEnable = wEnable & ~As<Int4>(wPredicate);
+ }
+ }
+
+ if(dst.x) d.x = As<Float4>(As<Int4>(d.x) & xEnable);
+ if(dst.y) d.y = As<Float4>(As<Int4>(d.y) & yEnable);
+ if(dst.z) d.z = As<Float4>(As<Int4>(d.z) & zEnable);
+ if(dst.w) d.w = As<Float4>(As<Int4>(d.w) & wEnable);
+
+ if(dst.x) d.x = As<Float4>(As<Int4>(d.x) | (As<Int4>(pDst.x) & ~xEnable));
+ if(dst.y) d.y = As<Float4>(As<Int4>(d.y) | (As<Int4>(pDst.y) & ~yEnable));
+ if(dst.z) d.z = As<Float4>(As<Int4>(d.z) | (As<Int4>(pDst.z) & ~zEnable));
+ if(dst.w) d.w = As<Float4>(As<Int4>(d.w) | (As<Int4>(pDst.w) & ~wEnable));
+ }
+
+ switch(dst.type)
+ {
+ case Dst::PARAMETER_TEMP:
+ if(dst.x) r.rf[dst.index].x = d.x;
+ if(dst.y) r.rf[dst.index].y = d.y;
+ if(dst.z) r.rf[dst.index].z = d.z;
+ if(dst.w) r.rf[dst.index].w = d.w;
+ break;
+ case Dst::PARAMETER_COLOROUT:
+ if(dst.x) r.oC[dst.index].x = d.x;
+ if(dst.y) r.oC[dst.index].y = d.y;
+ if(dst.z) r.oC[dst.index].z = d.z;
+ if(dst.w) r.oC[dst.index].w = d.w;
+ break;
+ case Dst::PARAMETER_PREDICATE:
+ if(dst.x) r.p0.x = d.x;
+ if(dst.y) r.p0.y = d.y;
+ if(dst.z) r.p0.z = d.z;
+ if(dst.w) r.p0.w = d.w;
+ break;
+ case Dst::PARAMETER_DEPTHOUT:
+ r.oDepth = d.x;
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+
+ if(returns)
+ {
+ Nucleus::setInsertBlock(returnBlock);
+ }
+ }
+
+ Short4 PixelRoutine::convertFixed12(Float4 &cf)
+ {
+ return RoundShort4(cf * Float4(0x1000, 0x1000, 0x1000, 0x1000));
+ }
+
+ void PixelRoutine::convertFixed12(Color4i &ci, Color4f &cf)
+ {
+ ci.r = convertFixed12(cf.r);
+ ci.g = convertFixed12(cf.g);
+ ci.b = convertFixed12(cf.b);
+ ci.a = convertFixed12(cf.a);
+ }
+
+ UShort4 PixelRoutine::convertFixed16(Float4 &cf, bool saturate)
+ {
+ return UShort4(cf * Float4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF), saturate);
+ }
+
+ void PixelRoutine::convertFixed16(Color4i &ci, Color4f &cf, bool saturate)
+ {
+ ci.r = convertFixed16(cf.r, saturate);
+ ci.g = convertFixed16(cf.g, saturate);
+ ci.b = convertFixed16(cf.b, saturate);
+ ci.a = convertFixed16(cf.a, saturate);
+ }
+
+ Float4 PixelRoutine::convertSigned12(Short4 &ci)
+ {
+ return Float4(ci) * Float4(1.0f / 0x0FFE);
+ }
+
+ void PixelRoutine::convertSigned12(Color4f &cf, Color4i &ci)
+ {
+ cf.r = convertSigned12(ci.r);
+ cf.g = convertSigned12(ci.g);
+ cf.b = convertSigned12(ci.b);
+ cf.a = convertSigned12(ci.a);
+ }
+
+ Float4 PixelRoutine::convertUnsigned16(UShort4 ci)
+ {
+ return Float4(ci) * Float4(1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF);
+ }
+
+ void PixelRoutine::sRGBtoLinear16_16(Registers &r, Color4i &c)
+ {
+ c.r = As<UShort4>(c.r) >> 4;
+ c.g = As<UShort4>(c.g) >> 4;
+ c.b = As<UShort4>(c.b) >> 4;
+
+ sRGBtoLinear12_16(r, c);
+ }
+
+ void PixelRoutine::sRGBtoLinear12_16(Registers &r, Color4i &c)
+ {
+ Pointer<Byte> LUT = r.constants + OFFSET(Constants,sRGBtoLin12_16);
+
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 0))), 0);
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 1))), 1);
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 2))), 2);
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 3))), 3);
+
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 0))), 0);
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 1))), 1);
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 2))), 2);
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 3))), 3);
+
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 0))), 0);
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 1))), 1);
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 2))), 2);
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 3))), 3);
+ }
+
+ void PixelRoutine::linearToSRGB16_16(Registers &r, Color4i &c)
+ {
+ c.r = As<UShort4>(c.r) >> 4;
+ c.g = As<UShort4>(c.g) >> 4;
+ c.b = As<UShort4>(c.b) >> 4;
+
+ linearToSRGB12_16(r, c);
+ }
+
+ void PixelRoutine::linearToSRGB12_16(Registers &r, Color4i &c)
+ {
+ Pointer<Byte> LUT = r.constants + OFFSET(Constants,linToSRGB12_16);
+
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 0))), 0);
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 1))), 1);
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 2))), 2);
+ c.r = Insert(c.r, *Pointer<Short>(LUT + 2 * Int(Extract(c.r, 3))), 3);
+
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 0))), 0);
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 1))), 1);
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 2))), 2);
+ c.g = Insert(c.g, *Pointer<Short>(LUT + 2 * Int(Extract(c.g, 3))), 3);
+
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 0))), 0);
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 1))), 1);
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 2))), 2);
+ c.b = Insert(c.b, *Pointer<Short>(LUT + 2 * Int(Extract(c.b, 3))), 3);
+ }
+
+ Float4 PixelRoutine::linearToSRGB(const Float4 &x) // Approximates x^(1.0/2.2)
+ {
+ Float4 sqrtx = Rcp_pp(RcpSqrt_pp(x));
+ Float4 sRGB = sqrtx * Float4(1.14f) - x * Float4(0.14f);
+
+ return Min(Max(sRGB, Float4(0.0f)), Float4(1.0f));
+ }
+
+ Float4 PixelRoutine::sRGBtoLinear(const Float4 &x) // Approximates x^2.2
+ {
+ Float4 linear = x * x;
+ linear = linear * Float4(0.73f) + linear * x * Float4(0.27f);
+
+ return Min(Max(linear, Float4(0.0f)), Float4(1.0f));
+ }
+
+ void PixelRoutine::MOV(Color4i &dst, Color4i &src0)
+ {
+ dst.r = src0.x;
+ dst.g = src0.y;
+ dst.b = src0.z;
+ dst.a = src0.w;
+ }
+
+ void PixelRoutine::ADD(Color4i &dst, Color4i &src0, Color4i &src1)
+ {
+ dst.r = AddSat(src0.x, src1.x);
+ dst.g = AddSat(src0.y, src1.y);
+ dst.b = AddSat(src0.z, src1.z);
+ dst.a = AddSat(src0.w, src1.w);
+ }
+
+ void PixelRoutine::SUB(Color4i &dst, Color4i &src0, Color4i &src1)
+ {
+ dst.r = SubSat(src0.x, src1.x);
+ dst.g = SubSat(src0.y, src1.y);
+ dst.b = SubSat(src0.z, src1.z);
+ dst.a = SubSat(src0.w, src1.w);
+ }
+
+ void PixelRoutine::MAD(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2)
+ {
+ // FIXME: Long fixed-point multiply fixup
+ {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);}
+ {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);}
+ {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);}
+ {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);}
+ }
+
+ void PixelRoutine::MUL(Color4i &dst, Color4i &src0, Color4i &src1)
+ {
+ // FIXME: Long fixed-point multiply fixup
+ {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.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.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.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);}
+ }
+
+ void PixelRoutine::DP3(Color4i &dst, Color4i &src0, Color4i &src1)
+ {
+ Short4 t0;
+ Short4 t1;
+
+ // FIXME: Long fixed-point multiply fixup
+ t0 = MulHigh(src0.x, src1.x); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0);
+ t1 = MulHigh(src0.y, src1.y); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+ t0 = AddSat(t0, t1);
+ t1 = MulHigh(src0.z, src1.z); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+ t0 = AddSat(t0, t1);
+
+ dst.r = t0;
+ dst.g = t0;
+ dst.b = t0;
+ dst.a = t0;
+ }
+
+ void PixelRoutine::DP4(Color4i &dst, Color4i &src0, Color4i &src1)
+ {
+ Short4 t0;
+ Short4 t1;
+
+ // FIXME: Long fixed-point multiply fixup
+ t0 = MulHigh(src0.x, src1.x); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0);
+ t1 = MulHigh(src0.y, src1.y); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+ t0 = AddSat(t0, t1);
+ t1 = MulHigh(src0.z, src1.z); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+ t0 = AddSat(t0, t1);
+ t1 = MulHigh(src0.w, src1.w); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+ t0 = AddSat(t0, t1);
+
+ dst.r = t0;
+ dst.g = t0;
+ dst.b = t0;
+ dst.a = t0;
+ }
+
+ void PixelRoutine::LRP(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2)
+ {
+ // FIXME: Long fixed-point multiply fixup
+ {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);}
+ {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);}
+ {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);}
+ {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);}
+ }
+
+ void PixelRoutine::TEXCOORD(Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate)
+ {
+ Float4 uw;
+ Float4 vw;
+ Float4 sw;
+
+ if(state.interpolant[2 + coordinate].component & 0x01)
+ {
+ uw = Max(u, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ uw = Min(uw, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ dst.r = convertFixed12(uw);
+ }
+ else
+ {
+ dst.r = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ }
+
+ if(state.interpolant[2 + coordinate].component & 0x02)
+ {
+ vw = Max(v, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ vw = Min(vw, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ dst.g = convertFixed12(vw);
+ }
+ else
+ {
+ dst.g = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ }
+
+ if(state.interpolant[2 + coordinate].component & 0x04)
+ {
+ sw = Max(s, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ sw = Min(sw, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ dst.b = convertFixed12(sw);
+ }
+ else
+ {
+ dst.b = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ }
+
+ dst.a = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ }
+
+ void PixelRoutine::TEXCRD(Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate, bool project)
+ {
+ Float4 uw = u;
+ Float4 vw = v;
+ Float4 sw = s;
+
+ if(project)
+ {
+ uw *= Rcp_pp(s);
+ vw *= Rcp_pp(s);
+ }
+
+ if(state.interpolant[2 + coordinate].component & 0x01)
+ {
+ uw *= Float4(0x1000, 0x1000, 0x1000, 0x1000);
+ uw = Max(uw, Float4(-0x8000, -0x8000, -0x8000, -0x8000));
+ uw = Min(uw, Float4(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF));
+ dst.r = RoundShort4(uw);
+ }
+ else
+ {
+ dst.r = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ }
+
+ if(state.interpolant[2 + coordinate].component & 0x02)
+ {
+ vw *= Float4(0x1000, 0x1000, 0x1000, 0x1000);
+ vw = Max(vw, Float4(-0x8000, -0x8000, -0x8000, -0x8000));
+ vw = Min(vw, Float4(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF));
+ dst.g = RoundShort4(vw);
+ }
+ else
+ {
+ dst.g = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ }
+
+ if(state.interpolant[2 + coordinate].component & 0x04)
+ {
+ sw *= Float4(0x1000, 0x1000, 0x1000, 0x1000);
+ sw = Max(sw, Float4(-0x8000, -0x8000, -0x8000, -0x8000));
+ sw = Min(sw, Float4(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF));
+ dst.b = RoundShort4(sw);
+ }
+ else
+ {
+ dst.b = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ }
+ }
+
+ void PixelRoutine::TEXDP3(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, Color4i &src)
+ {
+ TEXM3X3PAD(r, u, v, s, src, 0, false);
+
+ Short4 t0 = RoundShort4(r.u_ * Float4(0x1000, 0x1000, 0x1000, 0x1000));
+
+ dst.r = t0;
+ dst.g = t0;
+ dst.b = t0;
+ dst.a = t0;
+ }
+
+ void PixelRoutine::TEXDP3TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0)
+ {
+ TEXM3X3PAD(r, u, v, s, src0, 0, false);
+
+ r.v_ = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.w_ = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+ sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
+ }
+
+ void PixelRoutine::TEXKILL(Int cMask[4], Float4 &u, Float4 &v, Float4 &s)
+ {
+ Int kill = SignMask(CmpNLT(u, Float4(0, 0, 0, 0))) &
+ SignMask(CmpNLT(v, Float4(0, 0, 0, 0))) &
+ SignMask(CmpNLT(s, Float4(0, 0, 0, 0)));
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ cMask[q] &= kill;
+ }
+ }
+
+ void PixelRoutine::TEXKILL(Int cMask[4], Color4i &src)
+ {
+ Short4 test = src.r | src.g | src.b;
+ Int kill = SignMask(Pack(test, test)) ^ 0x0000000F;
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ cMask[q] &= kill;
+ }
+ }
+
+ void PixelRoutine::TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int sampler, bool project)
+ {
+ sampleTexture(r, dst, sampler, u, v, s, s, project);
+ }
+
+ void PixelRoutine::TEXLD(Registers &r, Color4i &dst, Color4i &src, int sampler, bool project)
+ {
+ Float4 u = Float4(src.r) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 v = Float4(src.g) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 s = Float4(src.b) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+
+ sampleTexture(r, dst, sampler, u, v, s, s, project);
+ }
+
+ void PixelRoutine::TEXBEM(Registers &r, Color4i &dst, Color4i &src, Float4 &u, Float4 &v, Float4 &s, int stage)
+ {
+ Float4 du = Float4(src.r) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 dv = Float4(src.g) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+
+ Float4 du2 = du;
+ Float4 dv2 = dv;
+
+ du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
+ dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
+ du += dv2;
+ dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
+ du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
+ dv += du2;
+
+ Float4 u_ = u + du;
+ Float4 v_ = v + dv;
+
+ sampleTexture(r, dst, stage, u_, v_, s, s);
+ }
+
+ void PixelRoutine::TEXBEML(Registers &r, Color4i &dst, Color4i &src, Float4 &u, Float4 &v, Float4 &s, int stage)
+ {
+ Float4 du = Float4(src.r) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 dv = Float4(src.g) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+
+ Float4 du2 = du;
+ Float4 dv2 = dv;
+
+ du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
+ dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
+ du += dv2;
+ dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
+ du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
+ dv += du2;
+
+ Float4 u_ = u + du;
+ Float4 v_ = v + dv;
+
+ sampleTexture(r, dst, stage, u_, v_, s, s);
+
+ Short4 L;
+
+ L = src.b;
+ L = MulHigh(L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceScale4)));
+ L = L << 4;
+ L = AddSat(L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceOffset4)));
+ L = Max(L, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+ L = Min(L, Short4(0x1000, 0x1000, 0x1000, 0x1000));
+
+ dst.r = MulHigh(dst.r, L); dst.r = dst.r << 4;
+ dst.g = MulHigh(dst.g, L); dst.g = dst.g << 4;
+ dst.b = MulHigh(dst.b, L); dst.b = dst.b << 4;
+ }
+
+ void PixelRoutine::TEXREG2AR(Registers &r, Color4i &dst, Color4i &src0, int stage)
+ {
+ Float4 u = Float4(src0.a) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 v = Float4(src0.r) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 s = Float4(src0.b) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+
+ sampleTexture(r, dst, stage, u, v, s, s);
+ }
+
+ void PixelRoutine::TEXREG2GB(Registers &r, Color4i &dst, Color4i &src0, int stage)
+ {
+ Float4 u = Float4(src0.g) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 v = Float4(src0.b) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 s = v;
+
+ sampleTexture(r, dst, stage, u, v, s, s);
+ }
+
+ void PixelRoutine::TEXREG2RGB(Registers &r, Color4i &dst, Color4i &src0, int stage)
+ {
+ Float4 u = Float4(src0.r) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 v = Float4(src0.g) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ Float4 s = Float4(src0.b) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+
+ sampleTexture(r, dst, stage, u, v, s, s);
+ }
+
+ void PixelRoutine::TEXM3X2DEPTH(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, Color4i &src, bool signedScaling)
+ {
+ TEXM3X2PAD(r, u, v, s, src, 1, signedScaling);
+
+ // z / w
+ r.u_ *= Rcp_pp(r.v_); // FIXME: Set result to 1.0 when division by zero
+
+ r.oDepth = r.u_;
+ }
+
+ void PixelRoutine::TEXM3X2PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Color4i &src0, int component, bool signedScaling)
+ {
+ TEXM3X3PAD(r, u, v, s, src0, component, signedScaling);
+ }
+
+ void PixelRoutine::TEXM3X2TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0, bool signedScaling)
+ {
+ TEXM3X2PAD(r, u, v, s, src0, 1, signedScaling);
+
+ r.w_ = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+ sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
+ }
+
+ void PixelRoutine::TEXM3X3(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, Color4i &src0, bool signedScaling)
+ {
+ TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
+
+ dst.r = RoundShort4(r.u_ * Float4(0x1000, 0x1000, 0x1000, 0x1000));
+ dst.g = RoundShort4(r.v_ * Float4(0x1000, 0x1000, 0x1000, 0x1000));
+ dst.b = RoundShort4(r.w_ * Float4(0x1000, 0x1000, 0x1000, 0x1000));
+ dst.a = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ }
+
+ void PixelRoutine::TEXM3X3PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Color4i &src0, int component, bool signedScaling)
+ {
+ if(component == 0 || previousScaling != signedScaling) // FIXME: Other source modifiers?
+ {
+ r.U = Float4(src0.r);
+ r.V = Float4(src0.g);
+ r.W = Float4(src0.b);
+
+ previousScaling = signedScaling;
+ }
+
+ Float4 x = r.U * u + r.V * v + r.W * s;
+
+ x *= Float4(1.0f / 0x1000, 1.0f / 0x1000, 1.0f / 0x1000, 1.0f / 0x1000);
+
+ switch(component)
+ {
+ case 0: r.u_ = x; break;
+ case 1: r.v_ = x; break;
+ case 2: r.w_ = x; break;
+ default: ASSERT(false);
+ }
+ }
+
+ void PixelRoutine::TEXM3X3SPEC(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0, Color4i &src1)
+ {
+ TEXM3X3PAD(r, u, v, s, src0, 2, false);
+
+ Float4 E[3]; // Eye vector
+
+ E[0] = Float4(src1.r) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ E[1] = Float4(src1.g) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+ E[2] = Float4(src1.b) * Float4(1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE, 1.0f / 0x0FFE);
+
+ // Reflection
+ Float4 u__;
+ Float4 v__;
+ Float4 w__;
+
+ // (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
+ u__ = r.u_ * E[0];
+ v__ = r.v_ * E[1];
+ w__ = r.w_ * E[2];
+ u__ += v__ + w__;
+ u__ += u__;
+ v__ = u__;
+ w__ = u__;
+ u__ *= r.u_;
+ v__ *= r.v_;
+ w__ *= r.w_;
+ r.u_ *= r.u_;
+ r.v_ *= r.v_;
+ r.w_ *= r.w_;
+ r.u_ += r.v_ + r.w_;
+ u__ -= E[0] * r.u_;
+ v__ -= E[1] * r.u_;
+ w__ -= E[2] * r.u_;
+
+ sampleTexture(r, dst, stage, u__, v__, w__, w__);
+ }
+
+ void PixelRoutine::TEXM3X3TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0, bool signedScaling)
+ {
+ TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
+
+ sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
+ }
+
+ void PixelRoutine::TEXM3X3VSPEC(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0)
+ {
+ TEXM3X3PAD(r, u, v, s, src0, 2, false);
+
+ Float4 E[3]; // Eye vector
+
+ E[0] = r.vw[2 + stage - 2];
+ E[1] = r.vw[2 + stage - 1];
+ E[2] = r.vw[2 + stage - 0];
+
+ // Reflection
+ Float4 u__;
+ Float4 v__;
+ Float4 w__;
+
+ // (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
+ u__ = r.u_ * E[0];
+ v__ = r.v_ * E[1];
+ w__ = r.w_ * E[2];
+ u__ += v__ + w__;
+ u__ += u__;
+ v__ = u__;
+ w__ = u__;
+ u__ *= r.u_;
+ v__ *= r.v_;
+ w__ *= r.w_;
+ r.u_ *= r.u_;
+ r.v_ *= r.v_;
+ r.w_ *= r.w_;
+ r.u_ += r.v_ + r.w_;
+ u__ -= E[0] * r.u_;
+ v__ -= E[1] * r.u_;
+ w__ -= E[2] * r.u_;
+
+ sampleTexture(r, dst, stage, u__, v__, w__, w__);
+ }
+
+ void PixelRoutine::TEXDEPTH(Registers &r)
+ {
+ r.u_ = Float4(r.ri[5].r);
+ r.v_ = Float4(r.ri[5].g);
+
+ // z / w
+ r.u_ *= Rcp_pp(r.v_); // FIXME: Set result to 1.0 when division by zero
+
+ r.oDepth = r.u_;
+ }
+
+ void PixelRoutine::CND(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2)
+ {
+ {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.r = t0;};
+ {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.g = t0;};
+ {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.b = t0;};
+ {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.a = t0;};
+ }
+
+ void PixelRoutine::CMP(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2)
+ {
+ {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.x); Short4 t1; t1 = src2.x; t1 &= t0; t0 = ~t0 & src1.x; t0 |= t1; dst.r = t0;};
+ {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.y); Short4 t1; t1 = src2.y; t1 &= t0; t0 = ~t0 & src1.y; t0 |= t1; dst.g = t0;};
+ {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.z); Short4 t1; t1 = src2.z; t1 &= t0; t0 = ~t0 & src1.z; t0 |= t1; dst.b = t0;};
+ {Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.w); Short4 t1; t1 = src2.w; t1 &= t0; t0 = ~t0 & src1.w; t0 |= t1; dst.a = t0;};
+ }
+
+ void PixelRoutine::BEM(Registers &r, Color4i &dst, Color4i &src0, Color4i &src1, int stage)
+ {
+ Short4 t0;
+ Short4 t1;
+
+ // dst.r = src0.r + BUMPENVMAT00(stage) * src1.r + BUMPENVMAT10(stage) * src1.g
+ t0 = MulHigh(src1.x, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[0][0]))); t0 = t0 << 4; // FIXME: Matrix components range? Overflow hazard.
+ t1 = MulHigh(src1.y, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[1][0]))); t1 = t1 << 4; // FIXME: Matrix components range? Overflow hazard.
+ t0 = AddSat(t0, t1);
+ t0 = AddSat(t0, src0.x);
+ dst.r = t0;
+
+ // dst.g = src0.g + BUMPENVMAT01(stage) * src1.r + BUMPENVMAT11(stage) * src1.g
+ t0 = MulHigh(src1.x, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[0][1]))); t0 = t0 << 4; // FIXME: Matrix components range? Overflow hazard.
+ t1 = MulHigh(src1.y, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[1][1]))); t1 = t1 << 4; // FIXME: Matrix components range? Overflow hazard.
+ t0 = AddSat(t0, t1);
+ t0 = AddSat(t0, src0.y);
+ dst.g = t0;
+ }
+
+ void PixelRoutine::M3X2(Registers &r, Color4f &dst, Color4f &src0, const Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+
+ dst.x = dot3(src0, row0);
+ dst.y = dot3(src0, row1);
+ }
+
+ void PixelRoutine::M3X3(Registers &r, Color4f &dst, Color4f &src0, const Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+
+ dst.x = dot3(src0, row0);
+ dst.y = dot3(src0, row1);
+ dst.z = dot3(src0, row2);
+ }
+
+ void PixelRoutine::M3X4(Registers &r, Color4f &dst, Color4f &src0, const Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+ Color4f row3 = reg(r, src1, 3);
+
+ dst.x = dot3(src0, row0);
+ dst.y = dot3(src0, row1);
+ dst.z = dot3(src0, row2);
+ dst.w = dot3(src0, row3);
+ }
+
+ void PixelRoutine::M4X3(Registers &r, Color4f &dst, Color4f &src0, const Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+
+ dst.x = dot4(src0, row0);
+ dst.y = dot4(src0, row1);
+ dst.z = dot4(src0, row2);
+ }
+
+ void PixelRoutine::M4X4(Registers &r, Color4f &dst, Color4f &src0, const Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+ Color4f row3 = reg(r, src1, 3);
+
+ dst.x = dot4(src0, row0);
+ dst.y = dot4(src0, row1);
+ dst.z = dot4(src0, row2);
+ dst.w = dot4(src0, row3);
+ }
+
+ void PixelRoutine::TEXLD(Registers &r, Color4f &dst, Color4f &src0, const Src &src1, bool project, bool bias)
+ {
+ Color4f tmp;
+
+ sampleTexture(r, tmp, src1.index, src0.u, src0.v, src0.s, src0.t, src0, src0, project, bias);
+
+ dst.x = tmp[(src1.swizzle >> 0) & 0x3];
+ dst.y = tmp[(src1.swizzle >> 2) & 0x3];
+ dst.z = tmp[(src1.swizzle >> 4) & 0x3];
+ dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+ }
+
+ void PixelRoutine::TEXLDD(Registers &r, Color4f &dst, Color4f &src0, const Src &src1, Color4f &src2, Color4f &src3, bool project, bool bias)
+ {
+ Color4f tmp;
+
+ sampleTexture(r, tmp, src1.index, src0.u, src0.v, src0.s, src0.t, src2, src3, project, bias, true);
+
+ dst.x = tmp[(src1.swizzle >> 0) & 0x3];
+ dst.y = tmp[(src1.swizzle >> 2) & 0x3];
+ dst.z = tmp[(src1.swizzle >> 4) & 0x3];
+ dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+ }
+
+ void PixelRoutine::TEXLDL(Registers &r, Color4f &dst, Color4f &src0, const Src &src1, bool project, bool bias)
+ {
+ Color4f tmp;
+
+ sampleTexture(r, tmp, src1.index, src0.u, src0.v, src0.s, src0.t, src0, src0, project, bias, false, true);
+
+ dst.x = tmp[(src1.swizzle >> 0) & 0x3];
+ dst.y = tmp[(src1.swizzle >> 2) & 0x3];
+ dst.z = tmp[(src1.swizzle >> 4) & 0x3];
+ dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+ }
+
+ void PixelRoutine::TEXKILL(Int cMask[4], Color4f &src, unsigned char mask)
+ {
+ Int kill = -1;
+
+ if(mask & 0x1) kill &= SignMask(CmpNLT(src.x, Float4(0, 0, 0, 0)));
+ if(mask & 0x2) kill &= SignMask(CmpNLT(src.y, Float4(0, 0, 0, 0)));
+ if(mask & 0x4) kill &= SignMask(CmpNLT(src.z, Float4(0, 0, 0, 0)));
+ if(mask & 0x8) kill &= SignMask(CmpNLT(src.w, Float4(0, 0, 0, 0)));
+
+ for(unsigned int q = 0; q < state.multiSample; q++)
+ {
+ cMask[q] &= kill;
+ }
+ }
+
+ void PixelRoutine::DSX(Color4f &dst, Color4f &src)
+ {
+ dst.x = src.x.yyyy - src.x.xxxx;
+ dst.y = src.y.yyyy - src.y.xxxx;
+ dst.z = src.z.yyyy - src.z.xxxx;
+ dst.w = src.w.yyyy - src.w.xxxx;
+ }
+
+ void PixelRoutine::DSY(Color4f &dst, Color4f &src)
+ {
+ dst.x = src.x.zzzz - src.x.xxxx;
+ dst.y = src.y.zzzz - src.y.xxxx;
+ dst.z = src.z.zzzz - src.z.xxxx;
+ dst.w = src.w.zzzz - src.w.xxxx;
+ }
+
+ void PixelRoutine::BREAK(Registers &r)
+ {
+ llvm::BasicBlock *deadBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+ if(breakDepth == 0)
+ {
+ Nucleus::createBr(endBlock);
+ }
+ else
+ {
+ r.enableBreak = r.enableBreak & ~r.enableStack[r.enableIndex];
+ Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+ branch(allBreak, endBlock, deadBlock);
+ }
+
+ Nucleus::setInsertBlock(deadBlock);
+ }
+
+ void PixelRoutine::BREAKC(Registers &r, Color4f &src0, Color4f &src1, Control control)
+ {
+ Int4 condition;
+
+ switch(control)
+ {
+ case Op::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+ case Op::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x); break;
+ case Op::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+ case Op::CONTROL_LT: condition = CmpLT(src0.x, src1.x); break;
+ case Op::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+ case Op::CONTROL_LE: condition = CmpLE(src0.x, src1.x); break;
+ default:
+ ASSERT(false);
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+ r.enableBreak = r.enableBreak & ~condition;
+ Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+ branch(allBreak, endBlock, continueBlock);
+ Nucleus::setInsertBlock(continueBlock);
+ }
+
+ void PixelRoutine::BREAKP(Registers &r, const Src &predicateRegister) // FIXME: Factor out parts common with BREAKC
+ {
+ Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+ if(predicateRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = ~condition;
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+ r.enableBreak = r.enableBreak & ~condition;
+ Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+ branch(allBreak, endBlock, continueBlock);
+ Nucleus::setInsertBlock(continueBlock);
+ }
+
+ void PixelRoutine::CALL(Registers &r, int labelIndex)
+ {
+ if(!labelBlock[labelIndex])
+ {
+ labelBlock[labelIndex] = Nucleus::createBasicBlock();
+ }
+
+ llvm::BasicBlock *retBlock = Nucleus::createBasicBlock();
+ callRetBlock.push_back(retBlock);
+
+ r.callStack[r.stackIndex++] = UInt((int)callRetBlock.size() - 1); // FIXME
+
+ Nucleus::createBr(labelBlock[labelIndex]);
+ Nucleus::setInsertBlock(retBlock);
+ }
+
+ void PixelRoutine::CALLNZ(Registers &r, int labelIndex, const Src &src)
+ {
+ if(src.type == Src::PARAMETER_CONSTBOOL)
+ {
+ CALLNZb(r, labelIndex, src);
+ }
+ else if(src.type == Src::PARAMETER_PREDICATE)
+ {
+ CALLNZp(r, labelIndex, src);
+ }
+ else ASSERT(false);
+ }
+
+ void PixelRoutine::CALLNZb(Registers &r, int labelIndex, const Src &boolRegister)
+ {
+ Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,ps.b[boolRegister.index])) != Byte(0)); // FIXME
+
+ if(boolRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = !condition;
+ }
+
+ if(!labelBlock[labelIndex])
+ {
+ labelBlock[labelIndex] = Nucleus::createBasicBlock();
+ }
+
+ llvm::BasicBlock *retBlock = Nucleus::createBasicBlock();
+ callRetBlock.push_back(retBlock);
+
+ r.callStack[r.stackIndex++] = UInt((int)callRetBlock.size() - 1); // FIXME
+
+ branch(condition, labelBlock[labelIndex], retBlock);
+ Nucleus::setInsertBlock(retBlock);
+ }
+
+ void PixelRoutine::CALLNZp(Registers &r, int labelIndex, const Src &predicateRegister)
+ {
+ Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+ if(predicateRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = ~condition;
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ if(!labelBlock[labelIndex])
+ {
+ labelBlock[labelIndex] = Nucleus::createBasicBlock();
+ }
+
+ llvm::BasicBlock *retBlock = Nucleus::createBasicBlock();
+ callRetBlock.push_back(retBlock);
+
+ r.callStack[r.stackIndex++] = UInt((int)callRetBlock.size() - 1); // FIXME
+
+ r.enableIndex++;
+ r.enableStack[r.enableIndex] = condition;
+
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, labelBlock[labelIndex], retBlock);
+ Nucleus::setInsertBlock(retBlock);
+
+ r.enableIndex--;
+ }
+
+ void PixelRoutine::ELSE(Registers &r)
+ {
+ ifDepth--;
+
+ llvm::BasicBlock *falseBlock = ifFalseBlock[ifDepth];
+ llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+ if(isConditionalIf[ifDepth])
+ {
+ Int4 condition = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, falseBlock, endBlock);
+
+ r.enableStack[r.enableIndex] = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+ }
+ else
+ {
+ Nucleus::createBr(endBlock);
+ Nucleus::setInsertBlock(falseBlock);
+ }
+
+ ifFalseBlock[ifDepth] = endBlock;
+
+ ifDepth++;
+ }
+
+ void PixelRoutine::ENDIF(Registers &r)
+ {
+ ifDepth--;
+
+ llvm::BasicBlock *endBlock = ifFalseBlock[ifDepth];
+
+ Nucleus::createBr(endBlock);
+ Nucleus::setInsertBlock(endBlock);
+
+ if(isConditionalIf[ifDepth])
+ {
+ breakDepth--;
+ r.enableIndex--;
+ }
+ }
+
+ void PixelRoutine::ENDREP(Registers &r)
+ {
+ loopRepDepth--;
+
+ llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(endBlock);
+
+ r.loopDepth--;
+ r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ void PixelRoutine::ENDLOOP(Registers &r)
+ {
+ loopRepDepth--;
+
+ r.aL[r.loopDepth] = r.aL[r.loopDepth] + r.increment[r.loopDepth]; // FIXME: +=
+
+ llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(endBlock);
+
+ r.loopDepth--;
+ r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ void PixelRoutine::IF(Registers &r, const Src &src)
+ {
+ if(src.type == Src::PARAMETER_CONSTBOOL)
+ {
+ IFb(r, src);
+ }
+ else if(src.type == Src::PARAMETER_PREDICATE)
+ {
+ IFp(r, src);
+ }
+ else ASSERT(false);
+ }
+
+ void PixelRoutine::IFb(Registers &r, const Src &boolRegister)
+ {
+ Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,ps.b[boolRegister.index])) != Byte(0)); // FIXME
+
+ if(boolRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = !condition;
+ }
+
+ llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+ branch(condition, trueBlock, falseBlock);
+
+ isConditionalIf[ifDepth] = false;
+ ifFalseBlock[ifDepth] = falseBlock;
+
+ ifDepth++;
+ }
+
+ void PixelRoutine::IFp(Registers &r, const Src &predicateRegister) // FIXME: Factor out parts common with IFC
+ {
+ Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+ if(predicateRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = ~condition;
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ r.enableIndex++;
+ r.enableStack[r.enableIndex] = condition;
+
+ llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, trueBlock, falseBlock);
+
+ isConditionalIf[ifDepth] = true;
+ ifFalseBlock[ifDepth] = falseBlock;
+
+ ifDepth++;
+ breakDepth++;
+ }
+
+ void PixelRoutine::IFC(Registers &r, Color4f &src0, Color4f &src1, Control control)
+ {
+ Int4 condition;
+
+ switch(control)
+ {
+ case Op::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+ case Op::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x); break;
+ case Op::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+ case Op::CONTROL_LT: condition = CmpLT(src0.x, src1.x); break;
+ case Op::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+ case Op::CONTROL_LE: condition = CmpLE(src0.x, src1.x); break;
+ default:
+ ASSERT(false);
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ r.enableIndex++;
+ r.enableStack[r.enableIndex] = condition;
+
+ llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, trueBlock, falseBlock);
+
+ isConditionalIf[ifDepth] = true;
+ ifFalseBlock[ifDepth] = falseBlock;
+
+ ifDepth++;
+ breakDepth++;
+ }
+
+ void PixelRoutine::LABEL(int labelIndex)
+ {
+ Nucleus::setInsertBlock(labelBlock[labelIndex]);
+ }
+
+ void PixelRoutine::LOOP(Registers &r, const Src &integerRegister)
+ {
+ r.loopDepth++;
+
+ r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][0]));
+ r.aL[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][1]));
+ r.increment[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][2]));
+
+ // If(r.increment[r.loopDepth] == 0)
+ // {
+ // r.increment[r.loopDepth] = 1;
+ // }
+
+ llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+ loopRepTestBlock[loopRepDepth] = testBlock;
+ loopRepEndBlock[loopRepDepth] = endBlock;
+
+ // FIXME: jump(testBlock)
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(testBlock);
+
+ branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+ Nucleus::setInsertBlock(loopBlock);
+
+ r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1; // FIXME: --
+
+ loopRepDepth++;
+ breakDepth = 0;
+ }
+
+ void PixelRoutine::REP(Registers &r, const Src &integerRegister)
+ {
+ r.loopDepth++;
+
+ r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][0]));
+ r.aL[r.loopDepth] = r.aL[r.loopDepth - 1];
+
+ llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+ loopRepTestBlock[loopRepDepth] = testBlock;
+ loopRepEndBlock[loopRepDepth] = endBlock;
+
+ // FIXME: jump(testBlock)
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(testBlock);
+
+ branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+ Nucleus::setInsertBlock(loopBlock);
+
+ r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1; // FIXME: --
+
+ loopRepDepth++;
+ breakDepth = 0;
+ }
+
+ void PixelRoutine::RET(Registers &r)
+ {
+ if(!returns)
+ {
+ returnBlock = Nucleus::createBasicBlock();
+ Nucleus::createBr(returnBlock);
+
+ returns = true;
+ }
+ else
+ {
+ // FIXME: Encapsulate
+ UInt index = r.callStack[--r.stackIndex];
+
+ llvm::BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
+ llvm::Value *value = Nucleus::createLoad(index.address);
+ llvm::Value *switchInst = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock.size());
+
+ for(unsigned int i = 0; i < callRetBlock.size(); i++)
+ {
+ Nucleus::addSwitchCase(switchInst, i, callRetBlock[i]);
+ }
+
+ Nucleus::setInsertBlock(unreachableBlock);
+ Nucleus::createUnreachable();
+ }
+ }
+
+ void PixelRoutine::writeDestination(Registers &r, Color4i &d, const Dst &dst)
+ {
+ switch(dst.type)
+ {
+ case Dst::PARAMETER_TEMP:
+ if(dst.mask & 0x1) r.ri[dst.index].x = d.x;
+ if(dst.mask & 0x2) r.ri[dst.index].y = d.y;
+ if(dst.mask & 0x4) r.ri[dst.index].z = d.z;
+ if(dst.mask & 0x8) r.ri[dst.index].w = d.w;
+ break;
+ case Dst::PARAMETER_INPUT:
+ if(dst.mask & 0x1) r.vi[dst.index].x = d.x;
+ if(dst.mask & 0x2) r.vi[dst.index].y = d.y;
+ if(dst.mask & 0x4) r.vi[dst.index].z = d.z;
+ if(dst.mask & 0x8) r.vi[dst.index].w = d.w;
+ break;
+ case Dst::PARAMETER_CONST: ASSERT(false); break;
+ case Dst::PARAMETER_TEXTURE:
+ if(dst.mask & 0x1) r.ti[dst.index].x = d.x;
+ if(dst.mask & 0x2) r.ti[dst.index].y = d.y;
+ if(dst.mask & 0x4) r.ti[dst.index].z = d.z;
+ if(dst.mask & 0x8) r.ti[dst.index].w = d.w;
+ break;
+ case Dst::PARAMETER_COLOROUT:
+ if(dst.mask & 0x1) r.vi[dst.index].x = d.x;
+ if(dst.mask & 0x2) r.vi[dst.index].y = d.y;
+ if(dst.mask & 0x4) r.vi[dst.index].z = d.z;
+ if(dst.mask & 0x8) r.vi[dst.index].w = d.w;
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ Color4i PixelRoutine::regi(Registers &r, const Src &src)
+ {
+ Color4i *reg;
+ int i = src.index;
+
+ Color4i c;
+
+ if(src.type == ShaderParameter::PARAMETER_CONST)
+ {
+ c.r = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][0]));
+ c.g = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][1]));
+ c.b = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][2]));
+ c.a = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][3]));
+ }
+
+ switch(src.type)
+ {
+ case Src::PARAMETER_TEMP: reg = &r.ri[i]; break;
+ case Src::PARAMETER_INPUT: reg = &r.vi[i]; break;
+ case Src::PARAMETER_CONST: reg = &c; break;
+ case Src::PARAMETER_TEXTURE: reg = &r.ti[i]; break;
+ case Src::PARAMETER_VOID: return r.ri[0]; // Dummy
+ case Src::PARAMETER_FLOATLITERAL: return r.ri[0]; // Dummy
+ default:
+ ASSERT(false);
+ }
+
+ Short4 &x = (*reg)[(src.swizzle >> 0) & 0x3];
+ Short4 &y = (*reg)[(src.swizzle >> 2) & 0x3];
+ Short4 &z = (*reg)[(src.swizzle >> 4) & 0x3];
+ Short4 &w = (*reg)[(src.swizzle >> 6) & 0x3];
+
+ Color4i mod;
+
+ switch(src.modifier)
+ {
+ case Src::MODIFIER_NONE:
+ mod.r = x;
+ mod.g = y;
+ mod.b = z;
+ mod.a = w;
+ break;
+ case Src::MODIFIER_BIAS:
+ mod.r = SubSat(x, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ mod.g = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ mod.b = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ mod.a = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ break;
+ case Src::MODIFIER_BIAS_NEGATE:
+ mod.r = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), x);
+ mod.g = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
+ mod.b = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
+ mod.a = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), w);
+ break;
+ case Src::MODIFIER_COMPLEMENT:
+ mod.r = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), x);
+ mod.g = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), y);
+ mod.b = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), z);
+ mod.a = SubSat(Short4(0x1000, 0x1000, 0x1000, 0x1000), w);
+ break;
+ case Src::MODIFIER_NEGATE:
+ mod.r = -x;
+ mod.g = -y;
+ mod.b = -z;
+ mod.a = -w;
+ break;
+ case Src::MODIFIER_X2:
+ mod.r = AddSat(x, x);
+ mod.g = AddSat(y, y);
+ mod.b = AddSat(z, z);
+ mod.a = AddSat(w, w);
+ break;
+ case Src::MODIFIER_X2_NEGATE:
+ mod.r = -AddSat(x, x);
+ mod.g = -AddSat(y, y);
+ mod.b = -AddSat(z, z);
+ mod.a = -AddSat(w, w);
+ break;
+ case Src::MODIFIER_SIGN:
+ mod.r = SubSat(x, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ mod.g = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ mod.b = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ mod.a = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+ mod.r = AddSat(mod.r, mod.r);
+ mod.g = AddSat(mod.g, mod.g);
+ mod.b = AddSat(mod.b, mod.b);
+ mod.a = AddSat(mod.a, mod.a);
+ break;
+ case Src::MODIFIER_SIGN_NEGATE:
+ mod.r = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), x);
+ mod.g = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
+ mod.b = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
+ mod.a = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), w);
+ mod.r = AddSat(mod.r, mod.r);
+ mod.g = AddSat(mod.g, mod.g);
+ mod.b = AddSat(mod.b, mod.b);
+ mod.a = AddSat(mod.a, mod.a);
+ break;
+ case Src::MODIFIER_DZ:
+ mod.r = x;
+ mod.g = y;
+ mod.b = z;
+ mod.a = w;
+ // Projection performed by texture sampler
+ break;
+ case Src::MODIFIER_DW:
+ mod.r = x;
+ mod.g = y;
+ mod.b = z;
+ mod.a = w;
+ // Projection performed by texture sampler
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ if(src.type == ShaderParameter::PARAMETER_CONST && (src.modifier == Src::MODIFIER_X2 || src.modifier == Src::MODIFIER_X2_NEGATE))
+ {
+ mod.r = Min(mod.r, Short4(0x1000, 0x1000, 0x1000, 0x1000)); mod.r = Max(mod.r, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
+ mod.g = Min(mod.g, Short4(0x1000, 0x1000, 0x1000, 0x1000)); mod.g = Max(mod.g, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
+ mod.b = Min(mod.b, Short4(0x1000, 0x1000, 0x1000, 0x1000)); mod.b = Max(mod.b, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
+ mod.a = Min(mod.a, Short4(0x1000, 0x1000, 0x1000, 0x1000)); mod.a = Max(mod.a, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
+ }
+
+ return mod;
+ }
+
+ Color4f PixelRoutine::reg(Registers &r, const Src &src, int offset)
+ {
+ Color4f reg;
+ int i = src.index + offset;
+
+ switch(src.type)
+ {
+ case Src::PARAMETER_TEMP: reg = r.rf[i]; break;
+ case Src::PARAMETER_INPUT:
+ {
+ if(!src.relative)
+ {
+ reg.x = r.vx[i];
+ reg.y = r.vy[i];
+ reg.z = r.vz[i];
+ reg.w = r.vw[i];
+ }
+ else if(src.relativeType == Src::PARAMETER_LOOP)
+ {
+ Int aL = r.aL[r.loopDepth];
+
+ reg.x = r.vx[i + aL];
+ reg.y = r.vy[i + aL];
+ reg.z = r.vz[i + aL];
+ reg.w = r.vw[i + aL];
+ }
+ else ASSERT(false);
+ }
+ break;
+ case Src::PARAMETER_CONST:
+ {
+ reg.r = reg.g = reg.b = reg.a = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[i]));
+
+ reg.r = reg.r.xxxx;
+ reg.g = reg.g.yyyy;
+ reg.b = reg.b.zzzz;
+ reg.a = reg.a.wwww;
+
+ if(localShaderConstants) // Constant may be known at compile time
+ {
+ for(int j = 0; j < pixelShader->getLength(); j++)
+ {
+ const ShaderInstruction &instruction = *pixelShader->getInstruction(j);
+
+ if(instruction.getOpcode() == ShaderOperation::OPCODE_DEF)
+ {
+ if(instruction.getDestinationParameter().index == i)
+ {
+ reg.r = Float4(instruction.getSourceParameter(0).value);
+ reg.g = Float4(instruction.getSourceParameter(1).value);
+ reg.b = Float4(instruction.getSourceParameter(2).value);
+ reg.a = Float4(instruction.getSourceParameter(3).value);
+
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case Src::PARAMETER_TEXTURE:
+ {
+ reg.x = r.vx[2 + i];
+ reg.y = r.vy[2 + i];
+ reg.z = r.vz[2 + i];
+ reg.w = r.vw[2 + i];
+ }
+ break;
+ case Src::PARAMETER_MISCTYPE:
+ if(src.index == 0) reg = r.vPos;
+ if(src.index == 1) reg = r.vFace;
+ break;
+ case Src::PARAMETER_SAMPLER: return r.rf[0]; // Dummy
+ case Src::PARAMETER_PREDICATE: return r.rf[0]; // Dummy
+ case Src::PARAMETER_VOID: return r.rf[0]; // Dummy
+ case Src::PARAMETER_FLOATLITERAL: return r.rf[0]; // Dummy
+ case Src::PARAMETER_CONSTINT: return r.rf[0]; // Dummy
+ case Src::PARAMETER_CONSTBOOL: return r.rf[0]; // Dummy
+ case Src::PARAMETER_LOOP: return r.rf[0]; // Dummy
+ default:
+ ASSERT(false);
+ }
+
+ Float4 &x = reg[(src.swizzle >> 0) & 0x3];
+ Float4 &y = reg[(src.swizzle >> 2) & 0x3];
+ Float4 &z = reg[(src.swizzle >> 4) & 0x3];
+ Float4 &w = reg[(src.swizzle >> 6) & 0x3];
+
+ Color4f mod;
+
+ switch(src.modifier)
+ {
+ case Src::MODIFIER_NONE:
+ mod.x = x;
+ mod.y = y;
+ mod.z = z;
+ mod.w = w;
+ break;
+ case Src::MODIFIER_NEGATE:
+ mod.x = -x;
+ mod.y = -y;
+ mod.z = -z;
+ mod.w = -w;
+ break;
+ case Src::MODIFIER_ABS:
+ mod.x = Abs(x);
+ mod.y = Abs(y);
+ mod.z = Abs(z);
+ mod.w = Abs(w);
+ break;
+ case Src::MODIFIER_ABS_NEGATE:
+ mod.x = -Abs(x);
+ mod.y = -Abs(y);
+ mod.z = -Abs(z);
+ mod.w = -Abs(w);
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ return mod;
+ }
+
+ bool PixelRoutine::colorUsed()
+ {
+ return state.colorWriteMask || state.alphaTestActive() || state.shaderContainsTexkill;
+ }
+
+ unsigned short PixelRoutine::pixelShaderVersion() const
+ {
+ return pixelShader ? pixelShader->getVersion() : 0x0000;
+ }
+}
diff --git a/src/Shader/PixelRoutine.hpp b/src/Shader/PixelRoutine.hpp
new file mode 100644
index 0000000..c1070ff
--- /dev/null
+++ b/src/Shader/PixelRoutine.hpp
@@ -0,0 +1,304 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_PixelRoutine_hpp
+#define sw_PixelRoutine_hpp
+
+#include "Rasterizer.hpp"
+#include "ShaderCore.hpp"
+
+#include "Types.hpp"
+
+namespace sw
+{
+ extern bool forceClearRegisters;
+
+ class PixelShader;
+ class SamplerCore;
+
+ class PixelRoutine : public Rasterizer, public ShaderCore
+ {
+ friend PixelProcessor; // FIXME
+
+ public:
+ PixelRoutine(const PixelProcessor::State &state, const PixelShader *pixelShader);
+
+ ~PixelRoutine();
+
+ protected:
+ struct Registers
+ {
+ Registers() : current(ri[0]), diffuse(vi[0]), specular(vi[1]), callStack(4), aL(4), increment(4), iteration(4), enableStack(1 + 24), vx(10), vy(10), vz(10), vw(10)
+ {
+ if(forceClearRegisters)
+ {
+ for(int i = 0; i < 10; i++)
+ {
+ vx[i] = Float4(0, 0, 0, 0);
+ vy[i] = Float4(0, 0, 0, 0);
+ vz[i] = Float4(0, 0, 0, 0);
+ vw[i] = Float4(0, 0, 0, 0);
+ }
+
+ for(int i = 0; i < 4; i++)
+ {
+ oC[i].r = Float4(0.0f);
+ oC[i].g = Float4(0.0f);
+ oC[i].b = Float4(0.0f);
+ oC[i].a = Float4(0.0f);
+ }
+ }
+
+ loopDepth = -1;
+ enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+
+ occlusion = 0;
+
+ #if PERF_PROFILE
+ for(int i = 0; i < PERF_TIMERS; i++)
+ {
+ cycles[i] = 0;
+ }
+ #endif
+ }
+
+ Pointer<Byte> constants;
+
+ Pointer<Byte> primitive;
+ Int cluster;
+ Pointer<Byte> data;
+
+ Float4 z[4];
+ Float4 rhw;
+
+ Float4 Dz[4];
+ Float4 Dw;
+ Float4 Dv[10][4];
+ Float4 Df;
+
+ Color4i ¤t;
+ Color4i &diffuse;
+ Color4i &specular;
+
+ Color4i ri[6];
+ Color4i vi[2];
+ Color4i ti[6];
+
+ Color4f rf[32];
+ Array<Float4> vx;
+ Array<Float4> vy;
+ Array<Float4> vz;
+ Array<Float4> vw;
+
+ Color4f vPos;
+ Color4f vFace;
+
+ Color4f oC[4];
+ Float4 oDepth;
+
+ Color4f p0;
+ Array<Int> aL;
+
+ Array<Int> increment;
+ Array<Int> iteration;
+
+ Int loopDepth;
+ Int stackIndex; // FIXME: Inc/decrement callStack
+ Array<UInt> callStack;
+
+ Int enableIndex;
+ Array<Int4> enableStack;
+ Int4 enableBreak;
+
+ // bem(l) offsets and luminance
+ Float4 du;
+ Float4 dv;
+ Short4 L;
+
+ // texm3x3 temporaries
+ Float4 u_; // FIXME
+ Float4 v_; // FIXME
+ Float4 w_; // FIXME
+ Float4 U; // FIXME
+ Float4 V; // FIXME
+ Float4 W; // FIXME
+
+ UInt occlusion;
+
+ #if PERF_PROFILE
+ Long cycles[PERF_TIMERS];
+ #endif
+ };
+
+ void quad(Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y);
+
+ Float4 interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
+ Float4 interpolateCentroid(Float4 &x, Float4 &y, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
+ void stencilTest(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask);
+ void stencilTest(Registers &r, Byte8 &value, Context::StencilCompareMode stencilCompareMode, bool CCW);
+ void stencilOperation(Registers &r, Byte8 &newValue, Byte8 &bufferValue, Context::StencilOperation stencilPassOperation, Context::StencilOperation stencilZFailOperation, Context::StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask);
+ void stencilOperation(Registers &r, Byte8 &output, Byte8 &bufferValue, Context::StencilOperation operation, bool CCW);
+ Bool depthTest(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
+ void blendTexture(Registers &r, Color4i ¤t, Color4i &temp, Color4i &texture, int stage);
+ void alphaTest(Registers &r, Int &aMask, Short4 &alpha);
+ void alphaToCoverage(Registers &r, Int cMask[4], Float4 &alpha);
+ Bool alphaTest(Registers &r, Int cMask[4], Color4i ¤t);
+ Bool alphaTest(Registers &r, Int cMask[4], Color4f &c0);
+ void fogBlend(Registers &r, Color4i ¤t, Float4 &fog, Float4 &z, Float4 &rhw);
+ void fogBlend(Registers &r, Color4f &c0, Float4 &fog, Float4 &z, Float4 &rhw);
+ void pixelFog(Registers &r, Float4 &visibility, Float4 &z, Float4 &rhw);
+ void specularPixel(Color4i ¤t, Color4i &specular);
+
+ void sampleTexture(Registers &r, Color4i &c, int coordinates, int sampler, bool project = false);
+ void sampleTexture(Registers &r, Color4i &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project = false, bool bias = false, bool fixed12 = true);
+ void sampleTexture(Registers &r, Color4i &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool project = false, bool bias = false, bool fixed12 = true, bool gradients = false, bool lodProvided = false);
+ void sampleTexture(Registers &r, Color4f &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool project = false, bool bias = false, bool gradients = false, bool lodProvided = false);
+
+ // Raster operations
+ void clampColor(Color4f oC[4]);
+ void rasterOperation(Color4i ¤t, Registers &r, Float4 &fog, Pointer<Byte> &cBuffer, Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
+ void rasterOperation(Color4f oC[4], Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
+ void blendFactor(Registers &r, const Color4i &blendFactor, const Color4i ¤t, const Color4i &pixel, Context::BlendFactor blendFactorActive);
+ void blendFactorAlpha(Registers &r, const Color4i &blendFactor, const Color4i ¤t, const Color4i &pixel, Context::BlendFactor blendFactorAlphaActive);
+ void alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Color4i ¤t, Int &x);
+ void writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &i, Color4i ¤t, Int &sMask, Int &zMask, Int &cMask);
+ void blendFactor(Registers &r, const Color4f &blendFactor, const Color4f &oC, const Color4f &pixel, Context::BlendFactor blendFactorActive);
+ void blendFactorAlpha(Registers &r, const Color4f &blendFactor, const Color4f &oC, const Color4f &pixel, Context::BlendFactor blendFactorAlphaActive);
+ void alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Color4f &oC, Int &x);
+ void writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &i, Color4f &oC, Int &sMask, Int &zMask, Int &cMask);
+ void writeStencil(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask);
+ void writeDepth(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask);
+
+ void ps_1_x(Registers &r, Int cMask[4]);
+ void ps_2_x(Registers &r, Int cMask[4]);
+
+ Short4 convertFixed12(Float4 &cf);
+ void convertFixed12(Color4i &ci, Color4f &cf);
+ Float4 convertSigned12(Short4 &ci);
+ void convertSigned12(Color4f &cf, Color4i &ci);
+ Float4 convertUnsigned16(UShort4 ci);
+ UShort4 convertFixed16(Float4 &cf, bool saturate = true);
+ void convertFixed16(Color4i &ci, Color4f &cf, bool saturate = true);
+ void sRGBtoLinear16_16(Registers &r, Color4i &c);
+ void sRGBtoLinear12_16(Registers &r, Color4i &c);
+ void linearToSRGB16_16(Registers &r, Color4i &c);
+ void linearToSRGB12_16(Registers &r, Color4i &c);
+ Float4 sRGBtoLinear(const Float4 &x);
+ Float4 linearToSRGB(const Float4 &x);
+
+ typedef Shader::Instruction::DestinationParameter Dst;
+ typedef Shader::Instruction::SourceParameter Src;
+ typedef Shader::Instruction::Operation Op;
+ typedef Shader::Instruction::Operation::Control Control;
+
+ // ps_1_x instructions
+ void MOV(Color4i &dst, Color4i &src0);
+ void ADD(Color4i &dst, Color4i &src0, Color4i &src1);
+ void SUB(Color4i &dst, Color4i &src0, Color4i &src1);
+ void MAD(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2);
+ void MUL(Color4i &dst, Color4i &src0, Color4i &src1);
+ void DP3(Color4i &dst, Color4i &src0, Color4i &src1);
+ void DP4(Color4i &dst, Color4i &src0, Color4i &src1);
+ void LRP(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2);
+ void TEXCOORD(Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate);
+ void TEXCRD(Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate, bool project);
+ void TEXDP3(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, Color4i &src);
+ void TEXDP3TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0);
+ void TEXKILL(Int cMask[4], Float4 &u, Float4 &v, Float4 &s);
+ void TEXKILL(Int cMask[4], Color4i &dst);
+ void TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, bool project);
+ void TEXLD(Registers &r, Color4i &dst, Color4i &src, int stage, bool project);
+ void TEXBEM(Registers &r, Color4i &dst, Color4i &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+ void TEXBEML(Registers &r, Color4i &dst, Color4i &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+ void TEXREG2AR(Registers &r, Color4i &dst, Color4i &src0, int stage);
+ void TEXREG2GB(Registers &r, Color4i &dst, Color4i &src0, int stage);
+ void TEXREG2RGB(Registers &r, Color4i &dst, Color4i &src0, int stage);
+ void TEXM3X2DEPTH(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, Color4i &src, bool signedScaling);
+ void TEXM3X2PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Color4i &src0, int component, bool signedScaling);
+ void TEXM3X2TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0, bool signedScaling);
+ void TEXM3X3(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, Color4i &src0, bool signedScaling);
+ void TEXM3X3PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Color4i &src0, int component, bool signedScaling);
+ void TEXM3X3SPEC(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0, Color4i &src1);
+ void TEXM3X3TEX(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0, bool singedScaling);
+ void TEXM3X3VSPEC(Registers &r, Color4i &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Color4i &src0);
+ void TEXDEPTH(Registers &r);
+ void CND(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2);
+ void CMP(Color4i &dst, Color4i &src0, Color4i &src1, Color4i &src2);
+ void BEM(Registers &r, Color4i &dst, Color4i &src0, Color4i &src1, int stage);
+
+ // ps_2_x instructions
+ void M3X2(Registers &r, Color4f &dst, Color4f &src0, const Src &src1);
+ void M3X3(Registers &r, Color4f &dst, Color4f &src0, const Src &src1);
+ void M3X4(Registers &r, Color4f &dst, Color4f &src0, const Src &src1);
+ void M4X3(Registers &r, Color4f &dst, Color4f &src0, const Src &src1);
+ void M4X4(Registers &r, Color4f &dst, Color4f &src0, const Src &src1);
+ void TEXLD(Registers &r, Color4f &dst, Color4f &src0, const Src &src1, bool project, bool bias);
+ void TEXLDD(Registers &r, Color4f &dst, Color4f &src0, const Src &src1, Color4f &src2, Color4f &src3, bool project, bool bias);
+ void TEXLDL(Registers &r, Color4f &dst, Color4f &src0, const Src &src1, bool project, bool bias);
+ void TEXKILL(Int cMask[4], Color4f &src, unsigned char mask);
+ void DSX(Color4f &dst, Color4f &src);
+ void DSY(Color4f &dst, Color4f &src);
+ void BREAK(Registers &r);
+ void BREAKC(Registers &r, Color4f &src0, Color4f &src1, Control);
+ void BREAKP(Registers &r, const Src &predicateRegister);
+ void CALL(Registers &r, int labelIndex);
+ void CALLNZ(Registers &r, int labelIndex, const Src &src);
+ void CALLNZb(Registers &r, int labelIndex, const Src &boolRegister);
+ void CALLNZp(Registers &r, int labelIndex, const Src &predicateRegister);
+ void ELSE(Registers &r);
+ void ENDIF(Registers &r);
+ void ENDLOOP(Registers &r);
+ void ENDREP(Registers &r);
+ void IF(Registers &r, const Src &src);
+ void IFb(Registers &r, const Src &boolRegister);
+ void IFp(Registers &r, const Src &predicateRegister);
+ void IFC(Registers &r, Color4f &src0, Color4f &src1, Control);
+ void LABEL(int labelIndex);
+ void LOOP(Registers &r, const Src &integerRegister);
+ void REP(Registers &r, const Src &integerRegister);
+ void RET(Registers &r);
+
+ void readConstant(Registers &r, int index);
+
+ void writeDestination(Registers &r, Color4i &d, const Dst &dst);
+ Color4i regi(Registers &r, const Src &src);
+ Color4f reg(Registers &r, const Src &src, int offset = 0);
+
+ bool colorUsed();
+ unsigned short pixelShaderVersion() const;
+
+ private:
+ SamplerCore *sampler[16];
+
+ bool perturbate;
+ bool luminance;
+ bool previousScaling;
+
+ bool returns;
+ int ifDepth;
+ int loopRepDepth;
+ int breakDepth;
+
+ // FIXME: Get rid of llvm::
+ llvm::BasicBlock *ifFalseBlock[24 + 24];
+ llvm::BasicBlock *loopRepTestBlock[4];
+ llvm::BasicBlock *loopRepEndBlock[4];
+ llvm::BasicBlock *labelBlock[2048];
+ std::vector<llvm::BasicBlock*> callRetBlock;
+ llvm::BasicBlock *returnBlock;
+ bool isConditionalIf[24 + 24];
+
+ const PixelShader *const pixelShader;
+ };
+}
+
+#endif // sw_PixelRoutine_hpp
diff --git a/src/Shader/PixelShader.cpp b/src/Shader/PixelShader.cpp
new file mode 100644
index 0000000..7bf072a
--- /dev/null
+++ b/src/Shader/PixelShader.cpp
@@ -0,0 +1,728 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "PixelShader.hpp"
+
+#include "Debug.hpp"
+
+namespace sw
+{
+ PixelShader::PixelShader(const unsigned long *token) : Shader(token)
+ {
+ parse(token);
+ }
+
+ PixelShader::~PixelShader()
+ {
+ }
+
+ void PixelShader::parse(const unsigned long *token)
+ {
+ minorVersion = (unsigned char)(token[0] & 0x000000FF);
+ majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
+ shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);
+
+ length = validate(token);
+ ASSERT(length != 0);
+
+ instruction = new Shader::Instruction*[length];
+
+ for(int i = 0; i < length; i++)
+ {
+ while((*token & 0x0000FFFF) == 0x0000FFFE) // Comment token
+ {
+ int length = (*token & 0x7FFF0000) >> 16;
+
+ token += length + 1;
+ }
+
+ int length = size(*token);
+
+ instruction[i] = new Instruction(token, length, majorVersion);
+
+ token += length + 1;
+ }
+
+ analyzeZOverride();
+ analyzeTexkill();
+ analyzeInterpolants();
+ analyzeDirtyConstants();
+ analyzeDynamicBranching();
+ analyzeSamplers();
+ }
+
+ int PixelShader::validate(const unsigned long *const token)
+ {
+ if(!token)
+ {
+ return 0;
+ }
+
+ unsigned short version = (unsigned short)(token[0] & 0x0000FFFF);
+ unsigned char minorVersion = (unsigned char)(token[0] & 0x000000FF);
+ unsigned char majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
+ ShaderType shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);
+
+ if(shaderType != SHADER_PIXEL || majorVersion > 3)
+ {
+ return 0;
+ }
+
+ int instructionCount = 1;
+
+ for(int i = 0; token[i] != 0x0000FFFF; i++)
+ {
+ if((token[i] & 0x0000FFFF) == 0x0000FFFE) // Comment token
+ {
+ int length = (token[i] & 0x7FFF0000) >> 16;
+
+ i += length;
+ }
+ else
+ {
+ ShaderOpcode opcode = (ShaderOpcode)(token[i] & 0x0000FFFF);
+
+ switch(opcode)
+ {
+ case ShaderOperation::OPCODE_RESERVED0:
+ case ShaderOperation::OPCODE_MOVA:
+ return 0; // Unsupported operation
+ default:
+ instructionCount++;
+ break;
+ }
+
+ i += size(token[i], version);
+ }
+ }
+
+ return instructionCount;
+ }
+
+ bool PixelShader::depthOverride() const
+ {
+ return zOverride;
+ }
+
+ bool PixelShader::containsTexkill() const
+ {
+ return texkill;
+ }
+
+ bool PixelShader::containsCentroid() const
+ {
+ return centroid;
+ }
+
+ bool PixelShader::usesDiffuse(int component) const
+ {
+ return semantic[0][component].active();
+ }
+
+ bool PixelShader::usesSpecular(int component) const
+ {
+ return semantic[1][component].active();
+ }
+
+ bool PixelShader::usesTexture(int coordinate, int component) const
+ {
+ return semantic[2 + coordinate][component].active();
+ }
+
+ void PixelShader::analyzeZOverride()
+ {
+ zOverride = false;
+
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getOpcode() == Instruction::Operation::OPCODE_TEXM3X2DEPTH ||
+ instruction[i]->getOpcode() == Instruction::Operation::OPCODE_TEXDEPTH ||
+ instruction[i]->getDestinationParameter().type == Instruction::DestinationParameter::PARAMETER_DEPTHOUT)
+ {
+ zOverride = true;
+
+ break;
+ }
+ }
+ }
+
+ void PixelShader::analyzeTexkill()
+ {
+ texkill = false;
+
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getOpcode() == Instruction::Operation::OPCODE_TEXKILL)
+ {
+ texkill = true;
+
+ break;
+ }
+ }
+ }
+
+ void PixelShader::analyzeInterpolants()
+ {
+ vPosDeclared = false;
+ vFaceDeclared = false;
+ centroid = false;
+
+ if(version < 0x0300)
+ {
+ // Set default mapping; disable unused interpolants below
+ semantic[0][0] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+ semantic[0][1] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+ semantic[0][2] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+ semantic[0][3] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+
+ semantic[1][0] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+ semantic[1][1] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+ semantic[1][2] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+ semantic[1][3] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+
+ for(int i = 0; i < 8; i++)
+ {
+ semantic[2 + i][0] = Semantic(ShaderOperation::USAGE_TEXCOORD, i);
+ semantic[2 + i][1] = Semantic(ShaderOperation::USAGE_TEXCOORD, i);
+ semantic[2 + i][2] = Semantic(ShaderOperation::USAGE_TEXCOORD, i);
+ semantic[2 + i][3] = Semantic(ShaderOperation::USAGE_TEXCOORD, i);
+ }
+
+ Instruction::Operation::SamplerType samplerType[16];
+
+ for(int i = 0; i < 16; i++)
+ {
+ samplerType[i] = Instruction::Operation::SAMPLER_UNKNOWN;
+ }
+
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getDestinationParameter().type == Instruction::SourceParameter::PARAMETER_SAMPLER)
+ {
+ int sampler = instruction[i]->getDestinationParameter().index;
+
+ samplerType[sampler] = instruction[i]->getSamplerType();
+ }
+ }
+
+ bool interpolant[10][4] = {false}; // Interpolants in use
+
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getDestinationParameter().type == Instruction::SourceParameter::PARAMETER_TEXTURE)
+ {
+ int index = instruction[i]->getDestinationParameter().index + 2;
+ int mask = instruction[i]->getDestinationParameter().mask;
+
+ switch(instruction[i]->getOpcode())
+ {
+ case Instruction::Operation::OPCODE_TEX:
+ case Instruction::Operation::OPCODE_TEXBEM:
+ case Instruction::Operation::OPCODE_TEXBEML:
+ case Instruction::Operation::OPCODE_TEXCOORD:
+ case Instruction::Operation::OPCODE_TEXDP3:
+ case Instruction::Operation::OPCODE_TEXDP3TEX:
+ case Instruction::Operation::OPCODE_TEXM3X2DEPTH:
+ case Instruction::Operation::OPCODE_TEXM3X2PAD:
+ case Instruction::Operation::OPCODE_TEXM3X2TEX:
+ case Instruction::Operation::OPCODE_TEXM3X3:
+ case Instruction::Operation::OPCODE_TEXM3X3PAD:
+ case Instruction::Operation::OPCODE_TEXM3X3TEX:
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ break;
+ case Instruction::Operation::OPCODE_TEXKILL:
+ if(majorVersion < 2)
+ {
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ }
+ else
+ {
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ interpolant[index][3] = true;
+ }
+ break;
+ case Instruction::Operation::OPCODE_TEXM3X3VSPEC:
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ interpolant[index - 2][3] = true;
+ interpolant[index - 1][3] = true;
+ interpolant[index - 0][3] = true;
+ break;
+ case Instruction::Operation::OPCODE_DCL:
+ break; // Ignore
+ default: // Arithmetic instruction
+ if(version >= 0x0104)
+ {
+ ASSERT(false);
+ }
+ }
+ }
+
+ for(int argument = 0; argument < 4; argument++)
+ {
+ if(instruction[i]->getSourceParameter(argument).type == Instruction::SourceParameter::PARAMETER_INPUT ||
+ instruction[i]->getSourceParameter(argument).type == Instruction::SourceParameter::PARAMETER_TEXTURE)
+ {
+ int index = instruction[i]->getSourceParameter(argument).index;
+ int swizzle = instruction[i]->getSourceParameter(argument).swizzle;
+ int mask = instruction[i]->getDestinationParameter().mask;
+
+ if(instruction[i]->getSourceParameter(argument).type == Instruction::SourceParameter::PARAMETER_TEXTURE)
+ {
+ index += 2;
+ }
+
+ switch(instruction[i]->getOpcode())
+ {
+ case Instruction::Operation::OPCODE_TEX:
+ case Instruction::Operation::OPCODE_TEXLDD:
+ case Instruction::Operation::OPCODE_TEXLDL:
+ {
+ int sampler = instruction[i]->getSourceParameter(1).index;
+
+ switch(samplerType[sampler])
+ {
+ case Instruction::Operation::SAMPLER_UNKNOWN:
+ if(version == 0x0104)
+ {
+ if((instruction[i]->getSourceParameter(0).swizzle & 0x30) == 0x20) // .xyz
+ {
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ }
+ else // .xyw
+ {
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][3] = true;
+ }
+ }
+ else
+ {
+ ASSERT(false);
+ }
+ break;
+ case Instruction::Operation::SAMPLER_1D:
+ interpolant[index][0] = true;
+ break;
+ case Instruction::Operation::SAMPLER_2D:
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ break;
+ case Instruction::Operation::SAMPLER_CUBE:
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ break;
+ case Instruction::Operation::SAMPLER_VOLUME:
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ if(instruction[i]->isBias())
+ {
+ interpolant[index][3] = true;
+ }
+
+ if(instruction[i]->isProject())
+ {
+ interpolant[index][3] = true;
+ }
+
+ if(version == 0x0104 && instruction[i]->getOpcode() == Instruction::Operation::OPCODE_TEX)
+ {
+ if(instruction[i]->getSourceParameter(0).modifier == Instruction::SourceParameter::MODIFIER_DZ)
+ {
+ interpolant[index][2] = true;
+ }
+
+ if(instruction[i]->getSourceParameter(0).modifier == Instruction::SourceParameter::MODIFIER_DW)
+ {
+ interpolant[index][3] = true;
+ }
+ }
+ }
+ break;
+ case Instruction::Operation::OPCODE_M3X2:
+ if(mask & 0x1)
+ {
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+
+ if(argument == 1)
+ {
+ if(mask & 0x2)
+ {
+ interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+ }
+ break;
+ case Instruction::Operation::OPCODE_M3X3:
+ if(mask & 0x1)
+ {
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+
+ if(argument == 1)
+ {
+ if(mask & 0x2)
+ {
+ interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+
+ if(mask & 0x4)
+ {
+ interpolant[index + 2][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index + 2][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index + 2][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index + 2][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+ }
+ break;
+ case Instruction::Operation::OPCODE_M3X4:
+ if(mask & 0x1)
+ {
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+
+ if(argument == 1)
+ {
+ if(mask & 0x2)
+ {
+ interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+
+ if(mask & 0x4)
+ {
+ interpolant[index + 2][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index + 2][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index + 2][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index + 2][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+
+ if(mask & 0x8)
+ {
+ interpolant[index + 3][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index + 3][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index + 3][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index + 3][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ }
+ }
+ break;
+ case Instruction::Operation::OPCODE_M4X3:
+ if(mask & 0x1)
+ {
+ interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+
+ if(argument == 1)
+ {
+ if(mask & 0x2)
+ {
+ interpolant[index + 1][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index + 1][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index + 1][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index + 1][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+
+ if(mask & 0x4)
+ {
+ interpolant[index + 2][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index + 2][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index + 2][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index + 2][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+ }
+ break;
+ case Instruction::Operation::OPCODE_M4X4:
+ if(mask & 0x1)
+ {
+ interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+
+ if(argument == 1)
+ {
+ if(mask & 0x2)
+ {
+ interpolant[index + 1][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index + 1][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index + 1][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index + 1][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+
+ if(mask & 0x4)
+ {
+ interpolant[index + 2][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index + 2][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index + 2][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index + 2][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+
+ if(mask & 0x8)
+ {
+ interpolant[index + 3][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index + 3][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index + 3][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index + 3][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+ }
+ break;
+ case Instruction::Operation::OPCODE_CRS:
+ if(mask & 0x1)
+ {
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x6);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x6);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x6);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x6);
+ }
+
+ if(mask & 0x2)
+ {
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x5);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x5);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x5);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x5);
+ }
+
+ if(mask & 0x4)
+ {
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x3);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x3);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x3);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x3);
+ }
+ break;
+ case Instruction::Operation::OPCODE_DP2ADD:
+ if(argument == 0 || argument == 1)
+ {
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x3);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x3);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x3);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x3);
+ }
+ else // argument == 2
+ {
+ interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+ }
+ break;
+ case Instruction::Operation::OPCODE_DP3:
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+ break;
+ case Instruction::Operation::OPCODE_DP4:
+ interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+ break;
+ case Instruction::Operation::OPCODE_SINCOS:
+ case Instruction::Operation::OPCODE_EXP:
+ case Instruction::Operation::OPCODE_LOG:
+ case Instruction::Operation::OPCODE_POW:
+ case Instruction::Operation::OPCODE_RCP:
+ case Instruction::Operation::OPCODE_RSQ:
+ interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+ interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+ interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+ interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+ break;
+ case Instruction::Operation::OPCODE_NRM:
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7 | mask);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7 | mask);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7 | mask);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7 | mask);
+ break;
+ case Instruction::Operation::OPCODE_MOV:
+ case Instruction::Operation::OPCODE_ADD:
+ case Instruction::Operation::OPCODE_SUB:
+ case Instruction::Operation::OPCODE_MUL:
+ case Instruction::Operation::OPCODE_MAD:
+ case Instruction::Operation::OPCODE_ABS:
+ case Instruction::Operation::OPCODE_CMP:
+ case Instruction::Operation::OPCODE_CND:
+ case Instruction::Operation::OPCODE_FRC:
+ case Instruction::Operation::OPCODE_LRP:
+ case Instruction::Operation::OPCODE_MAX:
+ case Instruction::Operation::OPCODE_MIN:
+ case Instruction::Operation::OPCODE_SETP:
+ case Instruction::Operation::OPCODE_BREAKC:
+ case Instruction::Operation::OPCODE_DSX:
+ case Instruction::Operation::OPCODE_DSY:
+ interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, mask);
+ interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, mask);
+ interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, mask);
+ interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, mask);
+ break;
+ case Instruction::Operation::OPCODE_TEXCOORD:
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ interpolant[index][3] = true;
+ break;
+ case Instruction::Operation::OPCODE_TEXDP3:
+ case Instruction::Operation::OPCODE_TEXDP3TEX:
+ case Instruction::Operation::OPCODE_TEXM3X2PAD:
+ case Instruction::Operation::OPCODE_TEXM3X3PAD:
+ case Instruction::Operation::OPCODE_TEXM3X2TEX:
+ case Instruction::Operation::OPCODE_TEXM3X3SPEC:
+ case Instruction::Operation::OPCODE_TEXM3X3VSPEC:
+ case Instruction::Operation::OPCODE_TEXBEM:
+ case Instruction::Operation::OPCODE_TEXBEML:
+ case Instruction::Operation::OPCODE_TEXM3X2DEPTH:
+ case Instruction::Operation::OPCODE_TEXM3X3:
+ case Instruction::Operation::OPCODE_TEXM3X3TEX:
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ break;
+ case Instruction::Operation::OPCODE_TEXREG2AR:
+ case Instruction::Operation::OPCODE_TEXREG2GB:
+ case Instruction::Operation::OPCODE_TEXREG2RGB:
+ break;
+ default:
+ // ASSERT(false); // Refine component usage
+ interpolant[index][0] = true;
+ interpolant[index][1] = true;
+ interpolant[index][2] = true;
+ interpolant[index][3] = true;
+ }
+ }
+ }
+ }
+
+ for(int index = 0; index < 10; index++)
+ {
+ for(int component = 0; component < 4; component++)
+ {
+ if(!interpolant[index][component])
+ {
+ semantic[index][component] = Semantic();
+ }
+ }
+ }
+ }
+ else // Shader Model 3.0 input declaration; v# indexable
+ {
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getOpcode() == ShaderOperation::OPCODE_DCL)
+ {
+ if(instruction[i]->getDestinationParameter().type == ShaderParameter::PARAMETER_INPUT)
+ {
+ unsigned char usage = instruction[i]->getUsage();
+ unsigned char index = instruction[i]->getUsageIndex();
+ unsigned char mask = instruction[i]->getDestinationParameter().mask;
+ unsigned char reg = instruction[i]->getDestinationParameter().index;
+
+ if(mask & 0x01)
+ {
+ semantic[reg][0] = Semantic(usage, index);
+ }
+
+ if(mask & 0x02)
+ {
+ semantic[reg][1] = Semantic(usage, index);
+ }
+
+ if(mask & 0x04)
+ {
+ semantic[reg][2] = Semantic(usage, index);
+ }
+
+ if(mask & 0x08)
+ {
+ semantic[reg][3] = Semantic(usage, index);
+ }
+ }
+ else if(instruction[i]->getDestinationParameter().type == ShaderParameter::PARAMETER_MISCTYPE)
+ {
+ unsigned char index = instruction[i]->getDestinationParameter().index;
+
+ if(index == 0)
+ {
+ vPosDeclared = true;
+ }
+ else if(index == 1)
+ {
+ vFaceDeclared = true;
+ }
+ else ASSERT(false);
+ }
+ }
+ }
+ }
+
+ if(version >= 0x0200)
+ {
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getOpcode() == ShaderOperation::OPCODE_DCL)
+ {
+ bool centroid = instruction[i]->getDestinationParameter().centroid;
+ unsigned char reg = instruction[i]->getDestinationParameter().index;
+
+ switch(instruction[i]->getDestinationParameter().type)
+ {
+ case ShaderParameter::PARAMETER_INPUT:
+ semantic[reg][0].centroid = centroid;
+ break;
+ case ShaderParameter::PARAMETER_TEXTURE:
+ semantic[2 + reg][0].centroid = centroid;
+ break;
+ }
+
+ this->centroid = this->centroid || centroid;
+ }
+ }
+ }
+ }
+}
diff --git a/src/Shader/PixelShader.hpp b/src/Shader/PixelShader.hpp
new file mode 100644
index 0000000..a0f9b99
--- /dev/null
+++ b/src/Shader/PixelShader.hpp
@@ -0,0 +1,54 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_PixelShader_hpp
+#define sw_PixelShader_hpp
+
+#include "Shader.hpp"
+
+namespace sw
+{
+ class PixelShader : public Shader
+ {
+ public:
+ PixelShader(const unsigned long *token);
+
+ virtual ~PixelShader();
+
+ static int validate(const unsigned long *const token); // Returns number of instructions if valid
+ bool depthOverride() const;
+ bool containsTexkill() const;
+ bool containsCentroid() const;
+ bool usesDiffuse(int component) const;
+ bool usesSpecular(int component) const;
+ bool usesTexture(int coordinate, int component) const;
+
+ Semantic semantic[10][4]; // FIXME: Private
+
+ bool vPosDeclared;
+ bool vFaceDeclared;
+
+ private:
+ void parse(const unsigned long *token);
+
+ void analyzeZOverride();
+ void analyzeTexkill();
+ void analyzeInterpolants();
+
+ bool zOverride;
+ bool texkill;
+ bool centroid;
+ };
+
+ typedef PixelShader::Instruction PixelShaderInstruction;
+}
+
+#endif // sw_PixelShader_hpp
diff --git a/src/Shader/SamplerCore.cpp b/src/Shader/SamplerCore.cpp
new file mode 100644
index 0000000..b7055c4
--- /dev/null
+++ b/src/Shader/SamplerCore.cpp
@@ -0,0 +1,1877 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "SamplerCore.hpp"
+
+#include "Constants.hpp"
+#include "Debug.hpp"
+
+namespace sw
+{
+ SamplerCore::SamplerCore(Pointer<Byte> &constants, const Sampler::State &state) : constants(constants), state(state)
+ {
+ }
+
+ void SamplerCore::sampleTexture(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool bias, bool fixed12, bool gradients, bool lodProvided)
+ {
+ #if PERF_PROFILE
+ AddAtomic(Pointer<Long>(&profiler.texOperations), Long(4));
+
+ if(state.compressedFormat)
+ {
+ AddAtomic(Pointer<Long>(&profiler.compressedTex), Long(4));
+ }
+ #endif
+
+ bool cubeTexture = state.textureType == TEXTURE_CUBE;
+ bool volumeTexture = state.textureType == TEXTURE_3D;
+
+ Float4 uuuu = u;
+ Float4 vvvv = v;
+ Float4 wwww = w;
+
+ if(state.textureType == TEXTURE_NULL)
+ {
+ c.r = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ c.g = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ c.b = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+
+ if(fixed12) // FIXME: Convert to fixed12 at higher level, when required
+ {
+ c.a = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ }
+ else
+ {
+ c.a = Short4((short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF); // FIXME
+ }
+ }
+ else
+ {
+ Int face[4];
+ Float4 lodU;
+ Float4 lodV;
+
+ if(cubeTexture)
+ {
+ cubeFace(face, uuuu, vvvv, lodU, lodV, u, v, w);
+ }
+
+ Float lod;
+ Float anisotropy;
+ Float4 uDelta;
+ Float4 vDelta;
+
+ if(!volumeTexture)
+ {
+ if(!cubeTexture)
+ {
+ computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, Float(q.x), dsx, dsy, bias, gradients, lodProvided);
+ }
+ else
+ {
+ computeLod(texture, lod, anisotropy, uDelta, vDelta, lodU, lodV, Float(q.x), dsx, dsy, bias, gradients, lodProvided);
+ }
+ }
+ else
+ {
+ computeLod3D(texture, lod, uuuu, vvvv, wwww, Float(q.x), dsx, dsy, bias, gradients, lodProvided);
+ }
+
+ if(cubeTexture)
+ {
+ uuuu += Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ vvvv += Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ }
+
+ if(!hasFloatTexture())
+ {
+ sampleFilter(texture, c, uuuu, vvvv, wwww, lod, anisotropy, uDelta, vDelta, face, lodProvided);
+ }
+ else
+ {
+ Color4f cf;
+
+ sampleFloatFilter(texture, cf, uuuu, vvvv, wwww, lod, anisotropy, uDelta, vDelta, face, lodProvided);
+
+ convertFixed12(c, cf);
+ }
+
+ if(fixed12 && !hasFloatTexture())
+ {
+ for(int component = 0; component < textureComponentCount(); component++)
+ {
+ if(state.sRGB && isRGBComponent(component))
+ {
+ sRGBtoLinear16_12(c[component]); // FIXME: Perform linearization at surface level for read-only textures
+ }
+ else
+ {
+ if(hasUnsignedTextureComponent(component))
+ {
+ c[component] = As<UShort4>(c[component]) >> 4;
+ }
+ else
+ {
+ c[component] = c[component] >> 3;
+ }
+ }
+ }
+ }
+
+ if(fixed12 && state.textureFilter != FILTER_GATHER)
+ {
+ int componentCount = textureComponentCount();
+
+ switch(state.textureFormat)
+ {
+ case FORMAT_R8:
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ case FORMAT_V8U8:
+ case FORMAT_Q8W8V8U8:
+ case FORMAT_X8L8V8U8:
+ case FORMAT_V16U16:
+ case FORMAT_A16W16V16U16:
+ case FORMAT_Q16W16V16U16:
+ case FORMAT_G8R8:
+ case FORMAT_G16R16:
+ case FORMAT_A16B16G16R16:
+ if(componentCount < 2) c.g = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ if(componentCount < 3) c.b = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ if(componentCount < 4) c.a = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ break;
+ case FORMAT_A8:
+ c.a = c.r;
+ c.r = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ c.g = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ c.b = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+ break;
+ case FORMAT_L8:
+ case FORMAT_L16:
+ c.g = c.r;
+ c.b = c.r;
+ c.a = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ break;
+ case FORMAT_A8L8:
+ c.a = c.g;
+ c.g = c.r;
+ c.b = c.r;
+ break;
+ case FORMAT_R32F:
+ c.g = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ case FORMAT_G32R32F:
+ c.b = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ c.a = Short4(0x1000, 0x1000, 0x1000, 0x1000);
+ case FORMAT_A32B32G32R32F:
+ break;
+ case FORMAT_D32F_LOCKABLE:
+ case FORMAT_D32F_TEXTURE:
+ case FORMAT_D32F_SHADOW:
+ c.g = c.r;
+ c.b = c.r;
+ c.a = c.r;
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+ }
+
+ void SamplerCore::sampleTexture(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool bias, bool gradients, bool lodProvided)
+ {
+ #if PERF_PROFILE
+ AddAtomic(Pointer<Long>(&profiler.texOperations), Long(4));
+
+ if(state.compressedFormat)
+ {
+ AddAtomic(Pointer<Long>(&profiler.compressedTex), Long(4));
+ }
+ #endif
+
+ bool cubeTexture = state.textureType == TEXTURE_CUBE;
+ bool volumeTexture = state.textureType == TEXTURE_3D;
+
+ if(state.textureType == TEXTURE_NULL)
+ {
+ c.r = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ c.g = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ c.b = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ c.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ }
+ else
+ {
+ if(hasFloatTexture()) // FIXME: Mostly identical to integer sampling
+ {
+ Float4 uuuu = u;
+ Float4 vvvv = v;
+ Float4 wwww = w;
+
+ Int face[4];
+ Float4 lodU;
+ Float4 lodV;
+
+ if(cubeTexture)
+ {
+ cubeFace(face, uuuu, vvvv, lodU, lodV, u, v, w);
+ }
+
+ Float lod;
+ Float anisotropy;
+ Float4 uDelta;
+ Float4 vDelta;
+
+ if(!volumeTexture)
+ {
+ if(!cubeTexture)
+ {
+ computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, Float(q.x), dsx, dsy, bias, gradients, lodProvided);
+ }
+ else
+ {
+ computeLod(texture, lod, anisotropy, uDelta, vDelta, lodU, lodV, Float(q.x), dsx, dsy, bias, gradients, lodProvided);
+ }
+ }
+ else
+ {
+ computeLod3D(texture, lod, uuuu, vvvv, wwww, Float(q.x), dsx, dsy, bias, gradients, lodProvided);
+ }
+
+ if(cubeTexture)
+ {
+ uuuu += Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ vvvv += Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ }
+
+ sampleFloatFilter(texture, c, uuuu, vvvv, wwww, lod, anisotropy, uDelta, vDelta, face, lodProvided);
+ }
+ else
+ {
+ Color4i ci;
+
+ sampleTexture(texture, ci, u, v, w, q, dsx, dsy, bias, false, gradients, lodProvided);
+
+ for(int component = 0; component < textureComponentCount(); component++)
+ {
+ if(state.sRGB && isRGBComponent(component))
+ {
+ sRGBtoLinear16_12(ci[component]); // FIXME: Perform linearization at surface level for read-only textures
+ convertSigned12(c[component], ci[component]);
+ }
+ else
+ {
+ if(hasUnsignedTextureComponent(component))
+ {
+ convertUnsigned16(c[component], ci[component]);
+ }
+ else
+ {
+ convertSigned15(c[component], ci[component]);
+ }
+ }
+ }
+ }
+
+ int componentCount = textureComponentCount();
+
+ if(state.textureFilter != FILTER_GATHER)
+ {
+ switch(state.textureFormat)
+ {
+ case FORMAT_R8:
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ case FORMAT_V8U8:
+ case FORMAT_Q8W8V8U8:
+ case FORMAT_X8L8V8U8:
+ case FORMAT_V16U16:
+ case FORMAT_A16W16V16U16:
+ case FORMAT_Q16W16V16U16:
+ case FORMAT_G8R8:
+ case FORMAT_G16R16:
+ case FORMAT_A16B16G16R16:
+ if(componentCount < 2) c.g = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ if(componentCount < 3) c.b = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ if(componentCount < 4) c.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case FORMAT_A8:
+ c.a = c.r;
+ c.r = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ c.g = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ c.b = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ break;
+ case FORMAT_L8:
+ case FORMAT_L16:
+ c.g = c.r;
+ c.b = c.r;
+ c.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case FORMAT_A8L8:
+ c.a = c.g;
+ c.g = c.r;
+ c.b = c.r;
+ break;
+ case FORMAT_R32F:
+ c.g = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ case FORMAT_G32R32F:
+ c.b = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ c.a = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ case FORMAT_A32B32G32R32F:
+ break;
+ case FORMAT_D32F_LOCKABLE:
+ case FORMAT_D32F_TEXTURE:
+ case FORMAT_D32F_SHADOW:
+ c.g = c.r;
+ c.b = c.r;
+ c.a = c.r;
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+ }
+
+ void SamplerCore::border(Short4 &mask, Float4 &coordinates)
+ {
+ Int4 border = As<Int4>(CmpLT(Abs(coordinates - Float4(0.5f)), Float4(0.5f)));
+ mask = As<Short4>(Int2(As<Int4>(Pack(border, border))));
+ }
+
+ void SamplerCore::border(Int4 &mask, Float4 &coordinates)
+ {
+ mask = As<Int4>(CmpLT(Abs(coordinates - Float4(0.5f)), Float4(0.5f)));
+ }
+
+ Short4 SamplerCore::offsetSample(Short4 &uvw, Pointer<Byte> &mipmap, int halfOffset, bool wrap, int count)
+ {
+ if(wrap)
+ {
+ switch(count)
+ {
+ case -1: return uvw - *Pointer<Short4>(mipmap + halfOffset);
+ case 0: return uvw;
+ case +1: return uvw + *Pointer<Short4>(mipmap + halfOffset);
+ case 2: return uvw + *Pointer<Short4>(mipmap + halfOffset) + *Pointer<Short4>(mipmap + halfOffset);
+ }
+ }
+ else // Clamp or mirror
+ {
+ switch(count)
+ {
+ case -1: return SubSat(As<UShort4>(uvw), *Pointer<UShort4>(mipmap + halfOffset));
+ case 0: return uvw;
+ case +1: return AddSat(As<UShort4>(uvw), *Pointer<UShort4>(mipmap + halfOffset));
+ case 2: return AddSat(AddSat(As<UShort4>(uvw), *Pointer<UShort4>(mipmap + halfOffset)), *Pointer<UShort4>(mipmap + halfOffset));
+ }
+ }
+
+ return uvw;
+ }
+
+ void SamplerCore::sampleFilter(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool lodProvided)
+ {
+ bool volumeTexture = state.textureType == TEXTURE_3D;
+
+ sampleAniso(texture, c, u, v, w, lod, anisotropy, uDelta, vDelta, face, false, lodProvided);
+
+ if(state.mipmapFilter > MIPMAP_POINT)
+ {
+ Color4i cc;
+
+ sampleAniso(texture, cc, u, v, w, lod, anisotropy, uDelta, vDelta, face, true, lodProvided);
+
+ lod *= Float(1 << 16);
+
+ UShort4 utri = UShort4(Float4(lod)); // FIXME: Optimize
+ Short4 stri = utri >> 1; // FIXME: Optimize
+
+ if(hasUnsignedTextureComponent(0)) cc.r = MulHigh(As<UShort4>(cc.r), utri); else cc.r = MulHigh(cc.r, stri);
+ if(hasUnsignedTextureComponent(1)) cc.g = MulHigh(As<UShort4>(cc.g), utri); else cc.g = MulHigh(cc.g, stri);
+ if(hasUnsignedTextureComponent(2)) cc.b = MulHigh(As<UShort4>(cc.b), utri); else cc.b = MulHigh(cc.b, stri);
+ if(hasUnsignedTextureComponent(3)) cc.a = MulHigh(As<UShort4>(cc.a), utri); else cc.a = MulHigh(cc.a, stri);
+
+ utri = ~utri;
+ stri = Short4(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF) - stri;
+
+ if(hasUnsignedTextureComponent(0)) c.r = MulHigh(As<UShort4>(c.r), utri); else c.r = MulHigh(c.r, stri);
+ if(hasUnsignedTextureComponent(1)) c.g = MulHigh(As<UShort4>(c.g), utri); else c.g = MulHigh(c.g, stri);
+ if(hasUnsignedTextureComponent(2)) c.b = MulHigh(As<UShort4>(c.b), utri); else c.b = MulHigh(c.b, stri);
+ if(hasUnsignedTextureComponent(3)) c.a = MulHigh(As<UShort4>(c.a), utri); else c.a = MulHigh(c.a, stri);
+
+ c.r += cc.r;
+ c.g += cc.g;
+ c.b += cc.b;
+ c.a += cc.a;
+
+ if(!hasUnsignedTextureComponent(0)) c.r += c.r;
+ if(!hasUnsignedTextureComponent(1)) c.g += c.g;
+ if(!hasUnsignedTextureComponent(2)) c.b += c.b;
+ if(!hasUnsignedTextureComponent(3)) c.a += c.a;
+ }
+
+ Short4 borderMask;
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER)
+ {
+ Short4 u0;
+
+ border(u0, u);
+
+ borderMask = u0;
+ }
+
+ if((AddressingMode)state.addressingModeV == ADDRESSING_BORDER)
+ {
+ Short4 v0;
+
+ border(v0, v);
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER)
+ {
+ borderMask &= v0;
+ }
+ else
+ {
+ borderMask = v0;
+ }
+ }
+
+ if((AddressingMode)state.addressingModeW == ADDRESSING_BORDER && volumeTexture)
+ {
+ Short4 s0;
+
+ border(s0, w);
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER ||
+ (AddressingMode)state.addressingModeV == ADDRESSING_BORDER)
+ {
+ borderMask &= s0;
+ }
+ else
+ {
+ borderMask = s0;
+ }
+ }
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER ||
+ (AddressingMode)state.addressingModeV == ADDRESSING_BORDER ||
+ ((AddressingMode)state.addressingModeW == ADDRESSING_BORDER && volumeTexture))
+ {
+ Short4 b;
+
+ c.r = borderMask & c.r | ~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[0])) >> (hasUnsignedTextureComponent(0) ? 0 : 1));
+ c.g = borderMask & c.g | ~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[1])) >> (hasUnsignedTextureComponent(1) ? 0 : 1));
+ c.b = borderMask & c.b | ~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[2])) >> (hasUnsignedTextureComponent(2) ? 0 : 1));
+ c.a = borderMask & c.a | ~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[3])) >> (hasUnsignedTextureComponent(3) ? 0 : 1));
+ }
+ }
+
+ void SamplerCore::sampleAniso(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, bool lodProvided)
+ {
+ if(state.textureFilter != FILTER_ANISOTROPIC || lodProvided)
+ {
+ sampleQuad(texture, c, u, v, w, lod, face, secondLOD);
+ }
+ else
+ {
+ Int a = RoundInt(anisotropy);
+
+ Color4i cSum;
+
+ cSum.r = Short4(0, 0, 0, 0);
+ cSum.g = Short4(0, 0, 0, 0);
+ cSum.b = Short4(0, 0, 0, 0);
+ cSum.a = Short4(0, 0, 0, 0);
+
+ Float4 A = *Pointer<Float4>(constants + OFFSET(Constants,uvWeight) + 16 * a);
+ Float4 B = *Pointer<Float4>(constants + OFFSET(Constants,uvStart) + 16 * a);
+ UShort4 cw = *Pointer<UShort4>(constants + OFFSET(Constants,cWeight) + 8 * a);
+ Short4 sw = Short4(cw >> 1);
+
+ Float4 du = uDelta;
+ Float4 dv = vDelta;
+
+ Float4 u0 = u + B * du;
+ Float4 v0 = v + B * dv;
+
+ du *= A;
+ dv *= A;
+
+ Int i = 0;
+
+ Do
+ {
+ sampleQuad(texture, c, u0, v0, w, lod, face, secondLOD);
+
+ u0 += du;
+ v0 += dv;
+
+ if(hasUnsignedTextureComponent(0)) cSum.r += As<Short4>(MulHigh(As<UShort4>(c.r), cw)); else cSum.r += MulHigh(c.r, sw);
+ if(hasUnsignedTextureComponent(1)) cSum.g += As<Short4>(MulHigh(As<UShort4>(c.g), cw)); else cSum.g += MulHigh(c.g, sw);
+ if(hasUnsignedTextureComponent(2)) cSum.b += As<Short4>(MulHigh(As<UShort4>(c.b), cw)); else cSum.b += MulHigh(c.b, sw);
+ if(hasUnsignedTextureComponent(3)) cSum.a += As<Short4>(MulHigh(As<UShort4>(c.a), cw)); else cSum.a += MulHigh(c.a, sw);
+
+ i++;
+ }
+ Until(i >= a)
+
+ if(hasUnsignedTextureComponent(0)) c.r = cSum.r; else c.r = AddSat(cSum.r, cSum.r);
+ if(hasUnsignedTextureComponent(1)) c.g = cSum.g; else c.g = AddSat(cSum.g, cSum.g);
+ if(hasUnsignedTextureComponent(2)) c.b = cSum.b; else c.b = AddSat(cSum.b, cSum.b);
+ if(hasUnsignedTextureComponent(3)) c.a = cSum.a; else c.a = AddSat(cSum.a, cSum.a);
+ }
+ }
+
+ void SamplerCore::sampleQuad(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Int face[4], bool secondLOD)
+ {
+ if(state.textureType != TEXTURE_3D)
+ {
+ sampleQuad2D(texture, c, u, v, lod, face, secondLOD);
+ }
+ else
+ {
+ sample3D(texture, c, u, v, w, lod, secondLOD);
+ }
+ }
+
+ void SamplerCore::sampleQuad2D(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float &lod, Int face[4], bool secondLOD)
+ {
+ int componentCount = textureComponentCount();
+ bool gather = state.textureFilter == FILTER_GATHER;
+
+ Pointer<Byte> mipmap;
+ Pointer<Byte> buffer[4];
+
+ selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+ Short4 uuuu;
+ Short4 vvvv;
+
+ address(uuuu, u, (AddressingMode)state.addressingModeU);
+ address(vvvv, v, (AddressingMode)state.addressingModeV);
+
+ if(state.textureFilter == FILTER_POINT)
+ {
+ sampleTexel(c, uuuu, vvvv, vvvv, mipmap, buffer);
+ }
+ else
+ {
+ Color4i c0;
+ Color4i c1;
+ Color4i c2;
+ Color4i c3;
+
+ Short4 uuuu0 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), (AddressingMode)state.addressingModeU == ADDRESSING_WRAP, gather ? 0 : -1);
+ Short4 vvvv0 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), (AddressingMode)state.addressingModeV == ADDRESSING_WRAP, gather ? 0 : -1);
+ Short4 uuuu1 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), (AddressingMode)state.addressingModeU == ADDRESSING_WRAP, gather ? 2 : +1);
+ Short4 vvvv1 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), (AddressingMode)state.addressingModeV == ADDRESSING_WRAP, gather ? 2 : +1);
+
+ sampleTexel(c0, uuuu0, vvvv0, vvvv0, mipmap, buffer);
+ sampleTexel(c1, uuuu1, vvvv0, vvvv0, mipmap, buffer);
+ sampleTexel(c2, uuuu0, vvvv1, vvvv1, mipmap, buffer);
+ sampleTexel(c3, uuuu1, vvvv1, vvvv1, mipmap, buffer);
+
+ if(!gather) // Blend
+ {
+ // Fractions
+ UShort4 f0u = uuuu0;
+ UShort4 f0v = vvvv0;
+
+ if(!state.hasNPOTTexture)
+ {
+ f0u = f0u << *Pointer<Long1>(mipmap + OFFSET(Mipmap,uInt)); // .u
+ f0v = f0v << *Pointer<Long1>(mipmap + OFFSET(Mipmap,vInt)); // .v
+ }
+ else
+ {
+ f0u = f0u * *Pointer<UShort4>(mipmap + OFFSET(Mipmap,width));
+ f0v = f0v * *Pointer<UShort4>(mipmap + OFFSET(Mipmap,height));
+ }
+
+ Short4 f1u = ~f0u;
+ Short4 f1v = ~f0v;
+
+ Short4 f0u0v = MulHigh(As<UShort4>(f0u), As<UShort4>(f0v));
+ Short4 f1u0v = MulHigh(As<UShort4>(f1u), As<UShort4>(f0v));
+ Short4 f0u1v = MulHigh(As<UShort4>(f0u), As<UShort4>(f1v));
+ Short4 f1u1v = MulHigh(As<UShort4>(f1u), As<UShort4>(f1v));
+
+ // Signed fractions
+ Short4 f1u1vs;
+ Short4 f0u1vs;
+ Short4 f1u0vs;
+ Short4 f0u0vs;
+
+ if(!hasUnsignedTextureComponent(0) || !hasUnsignedTextureComponent(1) || !hasUnsignedTextureComponent(2) || !hasUnsignedTextureComponent(3))
+ {
+ f1u1vs = As<UShort4>(f1u1v) >> 1;
+ f0u1vs = As<UShort4>(f0u1v) >> 1;
+ f1u0vs = As<UShort4>(f1u0v) >> 1;
+ f0u0vs = As<UShort4>(f0u0v) >> 1;
+ }
+
+ // Bilinear interpolation
+ if(componentCount >= 1)
+ {
+ if(has16bitTexture() && hasUnsignedTextureComponent(0))
+ {
+ c0.r = As<UShort4>(c0.r) - MulHigh(As<UShort4>(c0.r), f0u) + MulHigh(As<UShort4>(c1.r), f0u);
+ c2.r = As<UShort4>(c2.r) - MulHigh(As<UShort4>(c2.r), f0u) + MulHigh(As<UShort4>(c3.r), f0u);
+ c.r = As<UShort4>(c0.r) - MulHigh(As<UShort4>(c0.r), f0v) + MulHigh(As<UShort4>(c2.r), f0v);
+ }
+ else
+ {
+ if(hasUnsignedTextureComponent(0))
+ {
+ c0.r = MulHigh(As<UShort4>(c0.r), As<UShort4>(f1u1v));
+ c1.r = MulHigh(As<UShort4>(c1.r), As<UShort4>(f0u1v));
+ c2.r = MulHigh(As<UShort4>(c2.r), As<UShort4>(f1u0v));
+ c3.r = MulHigh(As<UShort4>(c3.r), As<UShort4>(f0u0v));
+ }
+ else
+ {
+ c0.r = MulHigh(c0.r, f1u1vs);
+ c1.r = MulHigh(c1.r, f0u1vs);
+ c2.r = MulHigh(c2.r, f1u0vs);
+ c3.r = MulHigh(c3.r, f0u0vs);
+ }
+
+ c.r = (c0.r + c1.r) + (c2.r + c3.r);
+ if(!hasUnsignedTextureComponent(0)) c.r = AddSat(c.r, c.r); // Correct for signed fractions
+ }
+ }
+
+ if(componentCount >= 2)
+ {
+ if(has16bitTexture() && hasUnsignedTextureComponent(1))
+ {
+ c0.g = As<UShort4>(c0.g) - MulHigh(As<UShort4>(c0.g), f0u) + MulHigh(As<UShort4>(c1.g), f0u);
+ c2.g = As<UShort4>(c2.g) - MulHigh(As<UShort4>(c2.g), f0u) + MulHigh(As<UShort4>(c3.g), f0u);
+ c.g = As<UShort4>(c0.g) - MulHigh(As<UShort4>(c0.g), f0v) + MulHigh(As<UShort4>(c2.g), f0v);
+ }
+ else
+ {
+ if(hasUnsignedTextureComponent(1))
+ {
+ c0.g = MulHigh(As<UShort4>(c0.g), As<UShort4>(f1u1v));
+ c1.g = MulHigh(As<UShort4>(c1.g), As<UShort4>(f0u1v));
+ c2.g = MulHigh(As<UShort4>(c2.g), As<UShort4>(f1u0v));
+ c3.g = MulHigh(As<UShort4>(c3.g), As<UShort4>(f0u0v));
+ }
+ else
+ {
+ c0.g = MulHigh(c0.g, f1u1vs);
+ c1.g = MulHigh(c1.g, f0u1vs);
+ c2.g = MulHigh(c2.g, f1u0vs);
+ c3.g = MulHigh(c3.g, f0u0vs);
+ }
+
+ c.g = (c0.g + c1.g) + (c2.g + c3.g);
+ if(!hasUnsignedTextureComponent(1)) c.g = AddSat(c.g, c.g); // Correct for signed fractions
+ }
+ }
+
+ if(componentCount >= 3)
+ {
+ if(has16bitTexture() && hasUnsignedTextureComponent(2))
+ {
+ c0.b = As<UShort4>(c0.b) - MulHigh(As<UShort4>(c0.b), f0u) + MulHigh(As<UShort4>(c1.b), f0u);
+ c2.b = As<UShort4>(c2.b) - MulHigh(As<UShort4>(c2.b), f0u) + MulHigh(As<UShort4>(c3.b), f0u);
+ c.b = As<UShort4>(c0.b) - MulHigh(As<UShort4>(c0.b), f0v) + MulHigh(As<UShort4>(c2.b), f0v);
+ }
+ else
+ {
+ if(hasUnsignedTextureComponent(2))
+ {
+ c0.b = MulHigh(As<UShort4>(c0.b), As<UShort4>(f1u1v));
+ c1.b = MulHigh(As<UShort4>(c1.b), As<UShort4>(f0u1v));
+ c2.b = MulHigh(As<UShort4>(c2.b), As<UShort4>(f1u0v));
+ c3.b = MulHigh(As<UShort4>(c3.b), As<UShort4>(f0u0v));
+ }
+ else
+ {
+ c0.b = MulHigh(c0.b, f1u1vs);
+ c1.b = MulHigh(c1.b, f0u1vs);
+ c2.b = MulHigh(c2.b, f1u0vs);
+ c3.b = MulHigh(c3.b, f0u0vs);
+ }
+
+ c.b = (c0.b + c1.b) + (c2.b + c3.b);
+ if(!hasUnsignedTextureComponent(2)) c.b = AddSat(c.b, c.b); // Correct for signed fractions
+ }
+ }
+
+ if(componentCount >= 4)
+ {
+ if(has16bitTexture() && hasUnsignedTextureComponent(3))
+ {
+ c0.a = As<UShort4>(c0.a) - MulHigh(As<UShort4>(c0.a), f0u) + MulHigh(As<UShort4>(c1.a), f0u);
+ c2.a = As<UShort4>(c2.a) - MulHigh(As<UShort4>(c2.a), f0u) + MulHigh(As<UShort4>(c3.a), f0u);
+ c.a = As<UShort4>(c0.a) - MulHigh(As<UShort4>(c0.a), f0v) + MulHigh(As<UShort4>(c2.a), f0v);
+ }
+ else
+ {
+ if(hasUnsignedTextureComponent(3))
+ {
+ c0.a = MulHigh(As<UShort4>(c0.a), As<UShort4>(f1u1v));
+ c1.a = MulHigh(As<UShort4>(c1.a), As<UShort4>(f0u1v));
+ c2.a = MulHigh(As<UShort4>(c2.a), As<UShort4>(f1u0v));
+ c3.a = MulHigh(As<UShort4>(c3.a), As<UShort4>(f0u0v));
+ }
+ else
+ {
+ c0.a = MulHigh(c0.a, f1u1vs);
+ c1.a = MulHigh(c1.a, f0u1vs);
+ c2.a = MulHigh(c2.a, f1u0vs);
+ c3.a = MulHigh(c3.a, f0u0vs);
+ }
+
+ c.a = (c0.a + c1.a) + (c2.a + c3.a);
+ if(!hasUnsignedTextureComponent(3)) c.a = AddSat(c.a, c.a); // Correct for signed fractions
+ }
+ }
+ }
+ else
+ {
+ c.r = c1.r;
+ c.g = c2.r;
+ c.b = c3.r;
+ c.a = c0.r;
+ }
+ }
+ }
+
+ void SamplerCore::sample3D(Pointer<Byte> &texture, Color4i &c_, Float4 &u_, Float4 &v_, Float4 &w_, Float &lod, bool secondLOD)
+ {
+ int componentCount = textureComponentCount();
+
+ Pointer<Byte> mipmap;
+ Pointer<Byte> buffer[4];
+ Int face[4];
+
+ selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+ Short4 uuuu;
+ Short4 vvvv;
+ Short4 wwww;
+
+ address(uuuu, u_, (AddressingMode)state.addressingModeU);
+ address(vvvv, v_, (AddressingMode)state.addressingModeV);
+ address(wwww, w_, (AddressingMode)state.addressingModeW);
+
+ if(state.textureFilter <= FILTER_POINT)
+ {
+ sampleTexel(c_, uuuu, vvvv, wwww, mipmap, buffer);
+ }
+ else
+ {
+ Color4i c[2][2][2];
+
+ Short4 u[2][2][2];
+ Short4 v[2][2][2];
+ Short4 s[2][2][2];
+
+ for(int i = 0; i < 2; i++)
+ {
+ for(int j = 0; j < 2; j++)
+ {
+ for(int k = 0; k < 2; k++)
+ {
+ u[i][j][k] = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), (AddressingMode)state.addressingModeU == ADDRESSING_WRAP, i * 2 - 1);
+ v[i][j][k] = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), (AddressingMode)state.addressingModeV == ADDRESSING_WRAP, j * 2 - 1);
+ s[i][j][k] = offsetSample(wwww, mipmap, OFFSET(Mipmap,wHalf), (AddressingMode)state.addressingModeW == ADDRESSING_WRAP, k * 2 - 1);
+ }
+ }
+ }
+
+ Short4 f[2][2][2];
+ Short4 fs[2][2][2];
+ Short4 f0u;
+ Short4 f0v;
+ Short4 f0s;
+ Short4 f1u;
+ Short4 f1v;
+ Short4 f1s;
+
+ // Fractions
+ f0u = u[0][0][0];
+ f0v = v[0][0][0];
+ f0s = s[0][0][0];
+
+ if(!state.hasNPOTTexture)
+ {
+ f0u = f0u << *Pointer<Long1>(mipmap + OFFSET(Mipmap,uInt));
+ f0v = f0v << *Pointer<Long1>(mipmap + OFFSET(Mipmap,vInt));
+ f0s = f0s << *Pointer<Long1>(mipmap + OFFSET(Mipmap,wInt));
+ }
+ else
+ {
+ f0u *= *Pointer<Short4>(mipmap + OFFSET(Mipmap,width));
+ f0v *= *Pointer<Short4>(mipmap + OFFSET(Mipmap,height));
+ f0s *= *Pointer<Short4>(mipmap + OFFSET(Mipmap,depth));
+ }
+
+ f1u = ~f0u;
+ f1v = ~f0v;
+ f1s = ~f0s;
+
+ f[1][1][1] = MulHigh(As<UShort4>(f1u), As<UShort4>(f1v));
+ f[0][1][1] = MulHigh(As<UShort4>(f0u), As<UShort4>(f1v));
+ f[1][0][1] = MulHigh(As<UShort4>(f1u), As<UShort4>(f0v));
+ f[0][0][1] = MulHigh(As<UShort4>(f0u), As<UShort4>(f0v));
+ f[1][1][0] = MulHigh(As<UShort4>(f1u), As<UShort4>(f1v));
+ f[0][1][0] = MulHigh(As<UShort4>(f0u), As<UShort4>(f1v));
+ f[1][0][0] = MulHigh(As<UShort4>(f1u), As<UShort4>(f0v));
+ f[0][0][0] = MulHigh(As<UShort4>(f0u), As<UShort4>(f0v));
+
+ f[1][1][1] = MulHigh(As<UShort4>(f[1][1][1]), As<UShort4>(f1s));
+ f[0][1][1] = MulHigh(As<UShort4>(f[0][1][1]), As<UShort4>(f1s));
+ f[1][0][1] = MulHigh(As<UShort4>(f[1][0][1]), As<UShort4>(f1s));
+ f[0][0][1] = MulHigh(As<UShort4>(f[0][0][1]), As<UShort4>(f1s));
+ f[1][1][0] = MulHigh(As<UShort4>(f[1][1][0]), As<UShort4>(f0s));
+ f[0][1][0] = MulHigh(As<UShort4>(f[0][1][0]), As<UShort4>(f0s));
+ f[1][0][0] = MulHigh(As<UShort4>(f[1][0][0]), As<UShort4>(f0s));
+ f[0][0][0] = MulHigh(As<UShort4>(f[0][0][0]), As<UShort4>(f0s));
+
+ // Signed fractions
+ if(!hasUnsignedTextureComponent(0) || !hasUnsignedTextureComponent(1) || !hasUnsignedTextureComponent(2) || !hasUnsignedTextureComponent(3))
+ {
+ fs[0][0][0] = As<UShort4>(f[0][0][0]) >> 1;
+ fs[0][0][1] = As<UShort4>(f[0][0][1]) >> 1;
+ fs[0][1][0] = As<UShort4>(f[0][1][0]) >> 1;
+ fs[0][1][1] = As<UShort4>(f[0][1][1]) >> 1;
+ fs[1][0][0] = As<UShort4>(f[1][0][0]) >> 1;
+ fs[1][0][1] = As<UShort4>(f[1][0][1]) >> 1;
+ fs[1][1][0] = As<UShort4>(f[1][1][0]) >> 1;
+ fs[1][1][1] = As<UShort4>(f[1][1][1]) >> 1;
+ }
+
+ for(int i = 0; i < 2; i++)
+ {
+ for(int j = 0; j < 2; j++)
+ {
+ for(int k = 0; k < 2; k++)
+ {
+ sampleTexel(c[i][j][k], u[i][j][k], v[i][j][k], s[i][j][k], mipmap, buffer);
+
+ if(componentCount >= 1) if(hasUnsignedTextureComponent(0)) c[i][j][k].r = MulHigh(As<UShort4>(c[i][j][k].r), As<UShort4>(f[1 - i][1 - j][1 - k])); else c[i][j][k].r = MulHigh(c[i][j][k].r, fs[1 - i][1 - j][1 - k]);
+ if(componentCount >= 2) if(hasUnsignedTextureComponent(1)) c[i][j][k].g = MulHigh(As<UShort4>(c[i][j][k].g), As<UShort4>(f[1 - i][1 - j][1 - k])); else c[i][j][k].g = MulHigh(c[i][j][k].g, fs[1 - i][1 - j][1 - k]);
+ if(componentCount >= 3) if(hasUnsignedTextureComponent(2)) c[i][j][k].b = MulHigh(As<UShort4>(c[i][j][k].b), As<UShort4>(f[1 - i][1 - j][1 - k])); else c[i][j][k].b = MulHigh(c[i][j][k].b, fs[1 - i][1 - j][1 - k]);
+ if(componentCount >= 4) if(hasUnsignedTextureComponent(3)) c[i][j][k].a = MulHigh(As<UShort4>(c[i][j][k].a), As<UShort4>(f[1 - i][1 - j][1 - k])); else c[i][j][k].a = MulHigh(c[i][j][k].a, fs[1 - i][1 - j][1 - k]);
+
+ if(i != 0 || j != 0 || k != 0)
+ {
+ if(componentCount >= 1) c[0][0][0].r += c[i][j][k].r;
+ if(componentCount >= 2) c[0][0][0].g += c[i][j][k].g;
+ if(componentCount >= 3) c[0][0][0].b += c[i][j][k].b;
+ if(componentCount >= 4) c[0][0][0].a += c[i][j][k].a;
+ }
+ }
+ }
+ }
+
+ if(componentCount >= 1) c_.r = c[0][0][0].r;
+ if(componentCount >= 2) c_.g = c[0][0][0].g;
+ if(componentCount >= 3) c_.b = c[0][0][0].b;
+ if(componentCount >= 4) c_.a = c[0][0][0].a;
+
+ // Correct for signed fractions
+ if(componentCount >= 1) if(!hasUnsignedTextureComponent(0)) c_.r = AddSat(c_.r, c_.r);
+ if(componentCount >= 2) if(!hasUnsignedTextureComponent(1)) c_.g = AddSat(c_.g, c_.g);
+ if(componentCount >= 3) if(!hasUnsignedTextureComponent(2)) c_.b = AddSat(c_.b, c_.b);
+ if(componentCount >= 4) if(!hasUnsignedTextureComponent(3)) c_.a = AddSat(c_.a, c_.a);
+ }
+ }
+
+ void SamplerCore::sampleFloatFilter(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool lodProvided)
+ {
+ bool volumeTexture = state.textureType == TEXTURE_3D;
+
+ sampleFloatAniso(texture, c, u, v, w, lod, anisotropy, uDelta, vDelta, face, false, lodProvided);
+
+ if(state.mipmapFilter > MIPMAP_POINT)
+ {
+ Color4f cc;
+
+ sampleFloatAniso(texture, cc, u, v, w, lod, anisotropy, uDelta, vDelta, face, true, lodProvided);
+
+ Float4 lod4 = Float4(Fraction(lod));
+
+ c.r = (cc.r - c.r) * lod4 + c.r;
+ c.g = (cc.g - c.g) * lod4 + c.g;
+ c.b = (cc.b - c.b) * lod4 + c.b;
+ c.a = (cc.a - c.a) * lod4 + c.a;
+ }
+
+ Int4 borderMask;
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER)
+ {
+ Int4 u0;
+
+ border(u0, u);
+
+ borderMask = u0;
+ }
+
+ if((AddressingMode)state.addressingModeV == ADDRESSING_BORDER)
+ {
+ Int4 v0;
+
+ border(v0, v);
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER)
+ {
+ borderMask &= v0;
+ }
+ else
+ {
+ borderMask = v0;
+ }
+ }
+
+ if((AddressingMode)state.addressingModeW == ADDRESSING_BORDER && volumeTexture)
+ {
+ Int4 s0;
+
+ border(s0, w);
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER ||
+ (AddressingMode)state.addressingModeV == ADDRESSING_BORDER)
+ {
+ borderMask &= s0;
+ }
+ else
+ {
+ borderMask = s0;
+ }
+ }
+
+ if((AddressingMode)state.addressingModeU == ADDRESSING_BORDER ||
+ (AddressingMode)state.addressingModeV == ADDRESSING_BORDER ||
+ ((AddressingMode)state.addressingModeW == ADDRESSING_BORDER && volumeTexture))
+ {
+ Int4 b;
+
+ c.r = As<Float4>(borderMask & As<Int4>(c.r) | ~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[0])));
+ c.g = As<Float4>(borderMask & As<Int4>(c.g) | ~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[1])));
+ c.b = As<Float4>(borderMask & As<Int4>(c.b) | ~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[2])));
+ c.a = As<Float4>(borderMask & As<Int4>(c.a) | ~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[3])));
+ }
+ }
+
+ void SamplerCore::sampleFloatAniso(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, bool lodProvided)
+ {
+ if(state.textureFilter != FILTER_ANISOTROPIC || lodProvided)
+ {
+ sampleFloat(texture, c, u, v, w, lod, face, secondLOD);
+ }
+ else
+ {
+ Int a = RoundInt(anisotropy);
+
+ Color4f cSum;
+
+ cSum.r = Float4(0, 0, 0, 0);
+ cSum.g = Float4(0, 0, 0, 0);
+ cSum.b = Float4(0, 0, 0, 0);
+ cSum.a = Float4(0, 0, 0, 0);
+
+ Float4 A = *Pointer<Float4>(constants + OFFSET(Constants,uvWeight) + 16 * a);
+ Float4 B = *Pointer<Float4>(constants + OFFSET(Constants,uvStart) + 16 * a);
+
+ Float4 du = uDelta;
+ Float4 dv = vDelta;
+
+ Float4 u0 = u + B * du;
+ Float4 v0 = v + B * dv;
+
+ du *= A;
+ dv *= A;
+
+ Int i = 0;
+
+ Do
+ {
+ sampleFloat(texture, c, u0, v0, w, lod, face, secondLOD);
+
+ u0 += du;
+ v0 += dv;
+
+ cSum.r += c.r * A;
+ cSum.g += c.g * A;
+ cSum.b += c.b * A;
+ cSum.a += c.a * A;
+
+ i++;
+ }
+ Until(i >= a)
+
+ c.r = cSum.r;
+ c.g = cSum.g;
+ c.b = cSum.b;
+ c.a = cSum.a;
+ }
+ }
+
+ void SamplerCore::sampleFloat(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Int face[4], bool secondLOD)
+ {
+ if(state.textureType != TEXTURE_3D)
+ {
+ sampleFloat2D(texture, c, u, v, w, lod, face, secondLOD);
+ }
+ else
+ {
+ sampleFloat3D(texture, c, u, v, w, lod, secondLOD);
+ }
+ }
+
+ void SamplerCore::sampleFloat2D(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &z, Float &lod, Int face[4], bool secondLOD)
+ {
+ int componentCount = textureComponentCount();
+ bool gather = state.textureFilter == FILTER_GATHER;
+
+ Pointer<Byte> mipmap;
+ Pointer<Byte> buffer[4];
+
+ selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+ Short4 uuuu;
+ Short4 vvvv;
+
+ address(uuuu, u, (AddressingMode)state.addressingModeU);
+ address(vvvv, v, (AddressingMode)state.addressingModeV);
+
+ if(state.textureFilter == FILTER_POINT)
+ {
+ sampleTexel(c, uuuu, vvvv, vvvv, z, mipmap, buffer);
+ }
+ else
+ {
+ Color4f c0;
+ Color4f c1;
+ Color4f c2;
+ Color4f c3;
+
+ Short4 uuuu0 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), (AddressingMode)state.addressingModeU == ADDRESSING_WRAP, gather ? 0 : -1);
+ Short4 vvvv0 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), (AddressingMode)state.addressingModeV == ADDRESSING_WRAP, gather ? 0 : -1);
+ Short4 uuuu1 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), (AddressingMode)state.addressingModeU == ADDRESSING_WRAP, gather ? 2 : +1);
+ Short4 vvvv1 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), (AddressingMode)state.addressingModeV == ADDRESSING_WRAP, gather ? 2 : +1);
+
+ sampleTexel(c0, uuuu0, vvvv0, vvvv0, z, mipmap, buffer);
+ sampleTexel(c1, uuuu1, vvvv0, vvvv0, z, mipmap, buffer);
+ sampleTexel(c2, uuuu0, vvvv1, vvvv1, z, mipmap, buffer);
+ sampleTexel(c3, uuuu1, vvvv1, vvvv1, z, mipmap, buffer);
+
+ if(!gather) // Blend
+ {
+ // Fractions
+ Float4 fu = Fraction(Float4(As<UShort4>(uuuu0)) * *Pointer<Float4>(mipmap + OFFSET(Mipmap,fWidth)));
+ Float4 fv = Fraction(Float4(As<UShort4>(vvvv0)) * *Pointer<Float4>(mipmap + OFFSET(Mipmap,fHeight)));
+
+ if(componentCount >= 1) c0.r = c0.r + fu * (c1.r - c0.r);
+ if(componentCount >= 2) c0.g = c0.g + fu * (c1.g - c0.g);
+ if(componentCount >= 3) c0.b = c0.b + fu * (c1.b - c0.b);
+ if(componentCount >= 4) c0.a = c0.a + fu * (c1.a - c0.a);
+
+ if(componentCount >= 1) c2.r = c2.r + fu * (c3.r - c2.r);
+ if(componentCount >= 2) c2.g = c2.g + fu * (c3.g - c2.g);
+ if(componentCount >= 3) c2.b = c2.b + fu * (c3.b - c2.b);
+ if(componentCount >= 4) c2.a = c2.a + fu * (c3.a - c2.a);
+
+ if(componentCount >= 1) c.r = c0.r + fv * (c2.r - c0.r);
+ if(componentCount >= 2) c.g = c0.g + fv * (c2.g - c0.g);
+ if(componentCount >= 3) c.b = c0.b + fv * (c2.b - c0.b);
+ if(componentCount >= 4) c.a = c0.a + fv * (c2.a - c0.a);
+ }
+ else
+ {
+ c.r = c1.r;
+ c.g = c2.r;
+ c.b = c3.r;
+ c.a = c0.r;
+ }
+ }
+ }
+
+ void SamplerCore::sampleFloat3D(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, bool secondLOD)
+ {
+ int componentCount = textureComponentCount();
+
+ Pointer<Byte> mipmap;
+ Pointer<Byte> buffer[4];
+ Int face[4];
+
+ selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+ Short4 uuuu;
+ Short4 vvvv;
+ Short4 wwww;
+
+ address(uuuu, u, (AddressingMode)state.addressingModeU);
+ address(vvvv, v, (AddressingMode)state.addressingModeV);
+ address(wwww, w, (AddressingMode)state.addressingModeW);
+
+ if(state.textureFilter <= FILTER_POINT)
+ {
+ sampleTexel(c, uuuu, vvvv, wwww, w, mipmap, buffer);
+ }
+ else
+ {
+ Color4f &c0 = c;
+ Color4f c1;
+ Color4f c2;
+ Color4f c3;
+ Color4f c4;
+ Color4f c5;
+ Color4f c6;
+ Color4f c7;
+
+ Short4 uuuu0 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), (AddressingMode)state.addressingModeU == ADDRESSING_WRAP, -1);
+ Short4 vvvv0 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), (AddressingMode)state.addressingModeV == ADDRESSING_WRAP, -1);
+ Short4 wwww0 = offsetSample(wwww, mipmap, OFFSET(Mipmap,wHalf), (AddressingMode)state.addressingModeW == ADDRESSING_WRAP, -1);
+ Short4 uuuu1 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), (AddressingMode)state.addressingModeU == ADDRESSING_WRAP, +1);
+ Short4 vvvv1 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), (AddressingMode)state.addressingModeV == ADDRESSING_WRAP, +1);
+ Short4 wwww1 = offsetSample(wwww, mipmap, OFFSET(Mipmap,wHalf), (AddressingMode)state.addressingModeW == ADDRESSING_WRAP, +1);
+
+ sampleTexel(c0, uuuu0, vvvv0, wwww0, w, mipmap, buffer);
+ sampleTexel(c1, uuuu1, vvvv0, wwww0, w, mipmap, buffer);
+ sampleTexel(c2, uuuu0, vvvv1, wwww0, w, mipmap, buffer);
+ sampleTexel(c3, uuuu1, vvvv1, wwww0, w, mipmap, buffer);
+ sampleTexel(c4, uuuu0, vvvv0, wwww1, w, mipmap, buffer);
+ sampleTexel(c5, uuuu1, vvvv0, wwww1, w, mipmap, buffer);
+ sampleTexel(c6, uuuu0, vvvv1, wwww1, w, mipmap, buffer);
+ sampleTexel(c7, uuuu1, vvvv1, wwww1, w, mipmap, buffer);
+
+ // Fractions
+ Float4 fu = Fraction(Float4(As<UShort4>(uuuu0)) * *Pointer<Float4>(mipmap + OFFSET(Mipmap,fWidth)));
+ Float4 fv = Fraction(Float4(As<UShort4>(vvvv0)) * *Pointer<Float4>(mipmap + OFFSET(Mipmap,fHeight)));
+ Float4 fw = Fraction(Float4(As<UShort4>(wwww0)) * *Pointer<Float4>(mipmap + OFFSET(Mipmap,fDepth)));
+
+ // Blend first slice
+ if(componentCount >= 1) c0.r = c0.r + fu * (c1.r - c0.r);
+ if(componentCount >= 2) c0.g = c0.g + fu * (c1.g - c0.g);
+ if(componentCount >= 3) c0.b = c0.b + fu * (c1.b - c0.b);
+ if(componentCount >= 4) c0.a = c0.a + fu * (c1.a - c0.a);
+
+ if(componentCount >= 1) c2.r = c2.r + fu * (c3.r - c2.r);
+ if(componentCount >= 2) c2.g = c2.g + fu * (c3.g - c2.g);
+ if(componentCount >= 3) c2.b = c2.b + fu * (c3.b - c2.b);
+ if(componentCount >= 4) c2.a = c2.a + fu * (c3.a - c2.a);
+
+ if(componentCount >= 1) c0.r = c0.r + fv * (c2.r - c0.r);
+ if(componentCount >= 2) c0.g = c0.g + fv * (c2.g - c0.g);
+ if(componentCount >= 3) c0.b = c0.b + fv * (c2.b - c0.b);
+ if(componentCount >= 4) c0.a = c0.a + fv * (c2.a - c0.a);
+
+ // Blend second slice
+ if(componentCount >= 1) c4.r = c4.r + fu * (c5.r - c4.r);
+ if(componentCount >= 2) c4.g = c4.g + fu * (c5.g - c4.g);
+ if(componentCount >= 3) c4.b = c4.b + fu * (c5.b - c4.b);
+ if(componentCount >= 4) c4.a = c4.a + fu * (c5.a - c4.a);
+
+ if(componentCount >= 1) c6.r = c6.r + fu * (c7.r - c6.r);
+ if(componentCount >= 2) c6.g = c6.g + fu * (c7.g - c6.g);
+ if(componentCount >= 3) c6.b = c6.b + fu * (c7.b - c6.b);
+ if(componentCount >= 4) c6.a = c6.a + fu * (c7.a - c6.a);
+
+ if(componentCount >= 1) c4.r = c4.r + fv * (c6.r - c4.r);
+ if(componentCount >= 2) c4.g = c4.g + fv * (c6.g - c4.g);
+ if(componentCount >= 3) c4.b = c4.b + fv * (c6.b - c4.b);
+ if(componentCount >= 4) c4.a = c4.a + fv * (c6.a - c4.a);
+
+ // Blend slices
+ if(componentCount >= 1) c0.r = c0.r + fw * (c4.r - c0.r);
+ if(componentCount >= 2) c0.g = c0.g + fw * (c4.g - c0.g);
+ if(componentCount >= 3) c0.b = c0.b + fw * (c4.b - c0.b);
+ if(componentCount >= 4) c0.a = c0.a + fw * (c4.a - c0.a);
+ }
+ }
+
+ void SamplerCore::computeLod(Pointer<Byte> &texture, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Float4 &uuuu, Float4 &vvvv, Float &lodBias, Color4f &dsx, Color4f &dsy, bool bias, bool gradients, bool lodProvided)
+ {
+ if(!lodProvided)
+ {
+ Float4 duvdxy;
+
+ if(!gradients)
+ {
+ duvdxy = Float4(uuuu.yz, vvvv.yz) - Float4(uuuu.xx, vvvv.xx);
+ }
+ else
+ {
+ Float4 dudxy = Float4(dsx.x.xx, dsy.x.xx);
+ Float4 dvdxy = Float4(dsx.y.xx, dsy.y.xx);
+
+ duvdxy = Float4(dudxy.xz, dvdxy.xz);
+ }
+
+ // Scale by texture dimensions and LOD
+ Float4 dUVdxy = duvdxy * *Pointer<Float4>(texture + OFFSET(Texture,widthHeightLOD));
+
+ Float4 dUV2dxy = dUVdxy * dUVdxy;
+ Float4 dUV2 = dUV2dxy.xy + dUV2dxy.zw;
+
+ lod = Max(Float(dUV2.x), Float(dUV2.y)); // Square length of major axis
+
+ if(state.textureFilter == FILTER_ANISOTROPIC)
+ {
+ Float det = Abs(Float(dUVdxy.x) * Float(dUVdxy.w) - Float(dUVdxy.y) * Float(dUVdxy.z));
+
+ Float4 dudx = duvdxy.xxxx;
+ Float4 dudy = duvdxy.yyyy;
+ Float4 dvdx = duvdxy.zzzz;
+ Float4 dvdy = duvdxy.wwww;
+
+ Int4 mask = As<Int4>(CmpNLT(dUV2.x, dUV2.y));
+ uDelta = As<Float4>(As<Int4>(dudx) & mask | As<Int4>(dudy) & ~mask);
+ vDelta = As<Float4>(As<Int4>(dvdx) & mask | As<Int4>(dvdy) & ~mask);
+
+ anisotropy = lod * Rcp_pp(det);
+ anisotropy = Min(anisotropy, *Pointer<Float>(texture + OFFSET(Texture,maxAnisotropy)));
+
+ lod *= Rcp_pp(anisotropy * anisotropy);
+ }
+
+ // log2(sqrt(lod))
+ lod = Float(As<Int>(lod));
+ lod -= Float(0x3F800000);
+ lod *= As<Float>(Int(0x33800000));
+
+ if(bias)
+ {
+ lod += lodBias;
+ }
+
+ // FIXME: Hack to satisfy WHQL
+ if(state.textureType == TEXTURE_CUBE)
+ {
+ lod += Float(-0.15f);
+ }
+ }
+ else
+ {
+ lod = lodBias + *Pointer<Float>(texture + OFFSET(Texture,LOD));
+ }
+
+ lod = Max(lod, Float(0));
+ lod = Min(lod, Float(MIPMAP_LEVELS - 2)); // Trilinear accesses lod+1
+ }
+
+ void SamplerCore::computeLod3D(Pointer<Byte> &texture, Float &lod, Float4 &uuuu, Float4 &vvvv, Float4 &wwww, Float &lodBias, Color4f &dsx, Color4f &dsy, bool bias, bool gradients, bool lodProvided)
+ {
+ if(state.mipmapFilter == MIPMAP_NONE)
+ {
+ }
+ else // Point and linear filter
+ {
+ if(!lodProvided)
+ {
+ Float4 dudxy;
+ Float4 dvdxy;
+ Float4 dsdxy;
+
+ if(!gradients)
+ {
+ dudxy = uuuu.ywyw - uuuu;
+ dvdxy = vvvv.ywyw - vvvv;
+ dsdxy = wwww.ywyw - wwww;
+ }
+ else
+ {
+ dudxy = dsx.x;
+ dvdxy = dsx.y;
+ dsdxy = dsx.z;
+
+ dudxy = Float4(dudxy.xx, dsy.x.xx);
+ dvdxy = Float4(dvdxy.xx, dsy.y.xx);
+ dsdxy = Float4(dsdxy.xx, dsy.z.xx);
+
+ dudxy = Float4(dudxy.xz, dudxy.xz);
+ dvdxy = Float4(dvdxy.xz, dvdxy.xz);
+ dsdxy = Float4(dsdxy.xz, dsdxy.xz);
+ }
+
+ // Scale by texture dimensions and LOD
+ dudxy *= *Pointer<Float4>(texture + OFFSET(Texture,widthLOD));
+ dvdxy *= *Pointer<Float4>(texture + OFFSET(Texture,heightLOD));
+ dsdxy *= *Pointer<Float4>(texture + OFFSET(Texture,depthLOD));
+
+ dudxy *= dudxy;
+ dvdxy *= dvdxy;
+ dsdxy *= dsdxy;
+
+ dudxy += dvdxy;
+ dudxy += dsdxy;
+
+ lod = Max(Float(dudxy.x), Float(dudxy.y)); // FIXME: Max(dudxy.x, dudxy.y);
+
+ // log2(sqrt(lod))
+ lod = Float(As<Int>(lod));
+ lod -= Float(0x3F800000);
+ lod *= As<Float>(Int(0x33800000));
+
+ if(bias)
+ {
+ lod += lodBias;
+ }
+ }
+ else
+ {
+ lod = lodBias + *Pointer<Float>(texture + OFFSET(Texture,LOD));
+ }
+
+ lod = Max(lod, Float(0.0f)); // FIXME
+ lod = Min(lod, Float(MIPMAP_LEVELS - 2)); // Trilinear accesses lod+1
+ }
+ }
+
+ void SamplerCore::cubeFace(Int face[4], Float4 &U, Float4 &V, Float4 &lodU, Float4 &lodV, Float4 &x, Float4 &y, Float4 &z)
+ {
+ Int4 xp = CmpNLE(x, Float4(0.0f, 0.0f, 0.0f, 0.0f)); // x > 0
+ Int4 yp = CmpNLE(y, Float4(0.0f, 0.0f, 0.0f, 0.0f)); // y > 0
+ Int4 zp = CmpNLE(z, Float4(0.0f, 0.0f, 0.0f, 0.0f)); // z > 0
+
+ Float4 absX = Abs(x);
+ Float4 absY = Abs(y);
+ Float4 absZ = Abs(z);
+ Int4 xy = CmpNLE(absX, absY); // abs(x) > abs(y)
+ Int4 yz = CmpNLE(absY, absZ); // abs(y) > abs(z)
+ Int4 zx = CmpNLE(absZ, absX); // abs(z) > abs(x)
+
+ Int4 xyz = ~zx & xy; // abs(x) > abs(y) && abs(x) > abs(z)
+ Int4 yzx = ~xy & yz; // abs(y) > abs(z) && abs(y) > abs(x)
+ Int4 zxy = ~yz & zx; // abs(z) > abs(x) && abs(z) > abs(y)
+
+ // FACE_POSITIVE_X = 000b
+ // FACE_NEGATIVE_X = 001b
+ // FACE_POSITIVE_Y = 010b
+ // FACE_NEGATIVE_Y = 011b
+ // FACE_POSITIVE_Z = 100b
+ // FACE_NEGATIVE_Z = 101b
+
+ Int yAxis = SignMask(yzx);
+ Int zAxis = SignMask(zxy);
+
+ Int4 n = (~xp & xyz) | (~yp & yzx) | (~zp & zxy);
+ Int negative = SignMask(n);
+
+ face[0] = *Pointer<Int>(constants + OFFSET(Constants,transposeBit0) + negative * 4);
+ face[0] |= *Pointer<Int>(constants + OFFSET(Constants,transposeBit1) + yAxis * 4);
+ face[0] |= *Pointer<Int>(constants + OFFSET(Constants,transposeBit2) + zAxis * 4);
+ face[1] = (face[0] >> 4) & 0x7;
+ face[2] = (face[0] >> 8) & 0x7;
+ face[3] = (face[0] >> 12) & 0x7;
+ face[0] &= 0x7;
+
+ // U = xyz * -z + ~xyz * (yzx * ~yp * -x + (yzx * ~yp) * x)
+ U = As<Float4>((xyz & As<Int4>(-z)) | (~xyz & (((yzx & ~yp) & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(x))));
+
+ // V = yzx * z + ~yzx * (~neg * -y + neg * y)
+ V = As<Float4>((~yzx & ((~n & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(y))) | (yzx & As<Int4>(z)));
+
+ // M = xyz * x + yzx * y + zxy * z
+ Float4 M = As<Float4>((xyz & As<Int4>(x)) | (yzx & As<Int4>(y)) | (zxy & As<Int4>(z)));
+
+ M = reciprocal(M);
+ U *= M * Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ V *= M * Float4(0.5f, 0.5f, 0.5f, 0.5f);
+
+ // Project coordinates onto one face for consistent LOD calculation
+ {
+ yp = Swizzle(yp, 0);
+ n = Swizzle(n, 0);
+ xyz = Swizzle(xyz, 0);
+ yzx = Swizzle(yzx, 0);
+ zxy = Swizzle(zxy, 0);
+
+ // U = xyz * -z + ~xyz * (yzx * ~yp * -x + (yzx * ~yp) * x)
+ lodU = As<Float4>((xyz & As<Int4>(-z)) | (~xyz & (((yzx & ~yp) & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(x))));
+
+ // V = yzx * z + ~yzx * (~neg * -y + neg * y)
+ lodV = As<Float4>((~yzx & ((~n & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(y))) | (yzx & As<Int4>(z)));
+
+ // M = xyz * x + yzx * y + zxy * z
+ Float4 M = As<Float4>((xyz & As<Int4>(x)) | (yzx & As<Int4>(y)) | (zxy & As<Int4>(z)));
+
+ M = Rcp_pp(M);
+ lodU *= M * Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ lodV *= M * Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ }
+ }
+
+ void SamplerCore::computeIndices(Int index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, const Pointer<Byte> &mipmap)
+ {
+ Short4 uuu2;
+
+ if(!state.hasNPOTTexture && !hasFloatTexture())
+ {
+ vvvv = As<UShort4>(vvvv) >> *Pointer<Long1>(mipmap + OFFSET(Mipmap,vFrac));
+ uuu2 = uuuu;
+ uuuu = As<Short4>(UnpackLow(uuuu, vvvv));
+ uuu2 = As<Short4>(UnpackHigh(uuu2, vvvv));
+ uuuu = As<Short4>(As<UInt2>(uuuu) >> *Pointer<Long1>(mipmap + OFFSET(Mipmap,uFrac)));
+ uuu2 = As<Short4>(As<UInt2>(uuu2) >> *Pointer<Long1>(mipmap + OFFSET(Mipmap,uFrac)));
+
+ if(state.textureType == TEXTURE_3D)
+ {
+ wwww = As<UShort4>(wwww) >> *Pointer<Long1>(mipmap + OFFSET(Mipmap,wFrac));
+ Short4 www2 = wwww;
+ wwww = As<Short4>(UnpackLow(wwww, wwww));
+ www2 = As<Short4>(UnpackHigh(www2, www2));
+ wwww = As<Short4>(As<UInt2>(wwww) >> 16);
+ www2 = As<Short4>(As<UInt2>(www2) >> 16);
+ wwww = As<Short4>(As<Int2>(wwww) << *Pointer<Long1>(mipmap + OFFSET(Mipmap,uInt)));
+ www2 = As<Short4>(As<Int2>(www2) << *Pointer<Long1>(mipmap + OFFSET(Mipmap,uInt)));
+ wwww = As<Short4>(As<Int2>(wwww) << *Pointer<Long1>(mipmap + OFFSET(Mipmap,vInt))); // FIXME: Combine uInt and vInt shift
+ www2 = As<Short4>(As<Int2>(www2) << *Pointer<Long1>(mipmap + OFFSET(Mipmap,vInt)));
+ uuuu = As<Short4>(As<Int2>(uuuu) + As<Int2>(wwww));
+ uuu2 = As<Short4>(As<Int2>(uuu2) + As<Int2>(www2));
+ }
+ }
+ else
+ {
+ uuuu = MulHigh(As<UShort4>(uuuu), *Pointer<UShort4>(mipmap + OFFSET(Mipmap,width)));
+ vvvv = MulHigh(As<UShort4>(vvvv), *Pointer<UShort4>(mipmap + OFFSET(Mipmap,height)));
+ uuu2 = uuuu;
+ uuuu = As<Short4>(UnpackLow(uuuu, vvvv));
+ uuu2 = As<Short4>(UnpackHigh(uuu2, vvvv));
+ uuuu = As<Short4>(MulAdd(uuuu, *Pointer<Short4>(mipmap + OFFSET(Mipmap,onePitchP))));
+ uuu2 = As<Short4>(MulAdd(uuu2, *Pointer<Short4>(mipmap + OFFSET(Mipmap,onePitchP))));
+
+ if(state.textureType == TEXTURE_3D)
+ {
+ wwww = MulHigh(As<UShort4>(wwww), *Pointer<UShort4>(mipmap + OFFSET(Mipmap,depth)));
+ Short4 www2 = wwww;
+ wwww = As<Short4>(UnpackLow(wwww, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ www2 = As<Short4>(UnpackHigh(www2, Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ wwww = As<Short4>(MulAdd(wwww, *Pointer<Short4>(mipmap + OFFSET(Mipmap,sliceP))));
+ www2 = As<Short4>(MulAdd(www2, *Pointer<Short4>(mipmap + OFFSET(Mipmap,sliceP))));
+ uuuu = As<Short4>(As<Int2>(uuuu) + As<Int2>(wwww));
+ uuu2 = As<Short4>(As<Int2>(uuu2) + As<Int2>(www2));
+ }
+ }
+
+ index[0] = Extract(As<Int2>(uuuu), 0);
+ index[1] = Extract(As<Int2>(uuuu), 1);
+ index[2] = Extract(As<Int2>(uuu2), 0);
+ index[3] = Extract(As<Int2>(uuu2), 1);
+ }
+
+ void SamplerCore::sampleTexel(Color4i &c, Short4 &uuuu, Short4 &vvvv, Short4 &wwww, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4])
+ {
+ Int index[4];
+
+ computeIndices(index, uuuu, vvvv, wwww, mipmap);
+
+ int f0 = state.textureType == TEXTURE_CUBE ? 0 : 0;
+ int f1 = state.textureType == TEXTURE_CUBE ? 1 : 0;
+ int f2 = state.textureType == TEXTURE_CUBE ? 2 : 0;
+ int f3 = state.textureType == TEXTURE_CUBE ? 3 : 0;
+
+ if(!has16bitTexture())
+ {
+ Int c0;
+ Int c1;
+ Int c2;
+ Int c3;
+
+ switch(textureComponentCount())
+ {
+ case 4:
+ {
+ Byte8 c0 = *Pointer<Byte8>(buffer[f0] + 4 * index[0]);
+ Byte8 c1 = *Pointer<Byte8>(buffer[f1] + 4 * index[1]);
+ Byte8 c2 = *Pointer<Byte8>(buffer[f2] + 4 * index[2]);
+ Byte8 c3 = *Pointer<Byte8>(buffer[f3] + 4 * index[3]);
+ c.r = UnpackLow(c0, c1);
+ c.g = UnpackLow(c2, c3);
+
+ switch(state.textureFormat)
+ {
+ case FORMAT_A8R8G8B8:
+ c.b = c.r;
+ c.b = As<Short4>(UnpackLow(c.b, c.g));
+ c.r = As<Short4>(UnpackHigh(c.r, c.g));
+ c.g = c.b;
+ c.a = c.r;
+ c.b = UnpackLow(As<Byte8>(c.b), As<Byte8>(c.b));
+ c.g = UnpackHigh(As<Byte8>(c.g), As<Byte8>(c.g));
+ c.r = UnpackLow(As<Byte8>(c.r), As<Byte8>(c.r));
+ c.a = UnpackHigh(As<Byte8>(c.a), As<Byte8>(c.a));
+ break;
+ case FORMAT_Q8W8V8U8:
+ c.b = c.r;
+ c.r = As<Short4>(UnpackLow(c.r, c.g));
+ c.b = As<Short4>(UnpackHigh(c.b, c.g));
+ c.g = c.r;
+ c.a = c.b;
+ c.r = UnpackLow(As<Byte8>(c.r), As<Byte8>(c.r));
+ c.g = UnpackHigh(As<Byte8>(c.g), As<Byte8>(c.g));
+ c.b = UnpackLow(As<Byte8>(c.b), As<Byte8>(c.b));
+ c.a = UnpackHigh(As<Byte8>(c.a), As<Byte8>(c.a));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ break;
+ case 3:
+ {
+ Byte8 c0 = *Pointer<Byte8>(buffer[f0] + 4 * index[0]);
+ Byte8 c1 = *Pointer<Byte8>(buffer[f1] + 4 * index[1]);
+ Byte8 c2 = *Pointer<Byte8>(buffer[f2] + 4 * index[2]);
+ Byte8 c3 = *Pointer<Byte8>(buffer[f3] + 4 * index[3]);
+ c.r = UnpackLow(c0, c1);
+ c.g = UnpackLow(c2, c3);
+
+ switch(state.textureFormat)
+ {
+ case FORMAT_X8R8G8B8:
+ c.b = c.r;
+ c.b = As<Short4>(UnpackLow(c.b, c.g));
+ c.r = As<Short4>(UnpackHigh(c.r, c.g));
+ c.g = c.b;
+ c.b = UnpackLow(As<Byte8>(c.b), As<Byte8>(c.b));
+ c.g = UnpackHigh(As<Byte8>(c.g), As<Byte8>(c.g));
+ c.r = UnpackLow(As<Byte8>(c.r), As<Byte8>(c.r));
+ break;
+ case FORMAT_X8L8V8U8:
+ c.b = c.r;
+ c.r = As<Short4>(UnpackLow(c.r, c.g));
+ c.b = As<Short4>(UnpackHigh(c.b, c.g));
+ c.g = c.r;
+ c.r = UnpackLow(As<Byte8>(c.r), As<Byte8>(Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ c.r = c.r << 8;
+ c.g = UnpackHigh(As<Byte8>(c.g), As<Byte8>(Short4(0x0000, 0x0000, 0x0000, 0x0000)));
+ c.g = c.g << 8;
+ c.b = UnpackLow(As<Byte8>(c.b), As<Byte8>(c.b));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ break;
+ case 2:
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f0] + 2 * index[0]), 0);
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f1] + 2 * index[1]), 1);
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f2] + 2 * index[2]), 2);
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f3] + 2 * index[3]), 3);
+
+ switch(state.textureFormat)
+ {
+ case FORMAT_G8R8:
+ case FORMAT_V8U8:
+ case FORMAT_A8L8:
+ // FIXME: Unpack properly to 0.16 format
+ c.g = c.r;
+ c.r = c.r << 8;
+ break;
+ default:
+ ASSERT(false);
+ }
+ break;
+ case 1:
+ c0 = Int(*Pointer<Byte>(buffer[f0] + index[0]));
+ c1 = Int(*Pointer<Byte>(buffer[f1] + index[1]));
+ c2 = Int(*Pointer<Byte>(buffer[f2] + index[2]));
+ c3 = Int(*Pointer<Byte>(buffer[f3] + index[3]));
+ c0 = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
+ c.r = As<Short4>(Int2(c0));
+ c.r = UnpackLow(As<Byte8>(c.r), As<Byte8>(c.r));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ else
+ {
+ switch(textureComponentCount())
+ {
+ case 4:
+ c.r = *Pointer<Short4>(buffer[f0] + 8 * index[0]);
+ c.g = *Pointer<Short4>(buffer[f1] + 8 * index[1]);
+ c.b = *Pointer<Short4>(buffer[f2] + 8 * index[2]);
+ c.a = *Pointer<Short4>(buffer[f3] + 8 * index[3]);
+ transpose4x4(c.r, c.g, c.b, c.a);
+ break;
+ case 2:
+ c.r = *Pointer<Short4>(buffer[f0] + 4 * index[0]);
+ c.r = As<Short4>(UnpackLow(c.r, *Pointer<Short4>(buffer[f1] + 4 * index[1])));
+ c.b = *Pointer<Short4>(buffer[f2] + 4 * index[2]);
+ c.b = As<Short4>(UnpackLow(c.b, *Pointer<Short4>(buffer[f3] + 4 * index[3])));
+ c.g = c.r;
+ c.r = As<Short4>(UnpackLow(As<Int2>(c.r), As<Int2>(c.b)));
+ c.g = As<Short4>(UnpackHigh(As<Int2>(c.g), As<Int2>(c.b)));
+ break;
+ case 1:
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f0] + 2 * index[0]), 0);
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f1] + 2 * index[1]), 1);
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f2] + 2 * index[2]), 2);
+ c.r = Insert(c.r, *Pointer<Short>(buffer[f3] + 2 * index[3]), 3);
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+
+ void SamplerCore::sampleTexel(Color4f &c, Short4 &uuuu, Short4 &vvvv, Short4 &wwww, Float4 &z, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4])
+ {
+ Int index[4];
+
+ computeIndices(index, uuuu, vvvv, wwww, mipmap);
+
+ int f0 = state.textureType == TEXTURE_CUBE ? 0 : 0;
+ int f1 = state.textureType == TEXTURE_CUBE ? 1 : 0;
+ int f2 = state.textureType == TEXTURE_CUBE ? 2 : 0;
+ int f3 = state.textureType == TEXTURE_CUBE ? 3 : 0;
+
+ // Read texels
+ switch(textureComponentCount())
+ {
+ case 4:
+ c.r = *Pointer<Float4>(buffer[f0] + index[0] * 16, 16);
+ c.g = *Pointer<Float4>(buffer[f1] + index[1] * 16, 16);
+ c.b = *Pointer<Float4>(buffer[f2] + index[2] * 16, 16);
+ c.a = *Pointer<Float4>(buffer[f3] + index[3] * 16, 16);
+ transpose4x4(c.r, c.g, c.b, c.a);
+ break;
+ case 2:
+ // FIXME: Optimal shuffling?
+ c.r.xy = *Pointer<Float4>(buffer[f0] + index[0] * 8);
+ c.r.zw = *Pointer<Float4>(buffer[f1] + index[1] * 8 - 8);
+ c.b.xy = *Pointer<Float4>(buffer[f2] + index[2] * 8);
+ c.b.zw = *Pointer<Float4>(buffer[f3] + index[3] * 8 - 8);
+ c.g = c.r;
+ c.r = Float4(c.r.xz, c.b.xz);
+ c.g = Float4(c.g.yw, c.b.yw);
+ break;
+ case 1:
+ // FIXME: Optimal shuffling?
+ c.r.x = *Pointer<Float>(buffer[f0] + index[0] * 4);
+ c.r.y = *Pointer<Float>(buffer[f1] + index[1] * 4);
+ c.r.z = *Pointer<Float>(buffer[f2] + index[2] * 4);
+ c.r.w = *Pointer<Float>(buffer[f3] + index[3] * 4);
+
+ if(state.textureFormat == FORMAT_D32F_SHADOW && state.textureFilter != FILTER_GATHER)
+ {
+ Float4 d = Min(Max(z, Float4(0.0f)), Float4(1.0f));
+
+ c.r = As<Float4>(As<Int4>(CmpNLT(c.r, d)) & As<Int4>(Float4(1.0f, 1.0f, 1.0f, 1.0f))); // FIXME: Only less-equal?
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ void SamplerCore::selectMipmap(Pointer<Byte> &texture, Pointer<Byte> buffer[4], Pointer<Byte> &mipmap, Float &lod, Int face[4], bool secondLOD)
+ {
+ if(state.mipmapFilter < MIPMAP_POINT)
+ {
+ mipmap = texture + OFFSET(Texture,mipmap[0]);
+ }
+ else
+ {
+ Int ilod;
+
+ if(state.mipmapFilter == MIPMAP_POINT)
+ {
+ ilod = RoundInt(lod);
+ }
+ else // Linear
+ {
+ ilod = Int(lod);
+ }
+
+ mipmap = texture + OFFSET(Texture,mipmap) + ilod * sizeof(Mipmap) + secondLOD * sizeof(Mipmap);
+ }
+
+ if(state.textureType != TEXTURE_CUBE)
+ {
+ buffer[0] = *Pointer<Pointer<Byte>>(mipmap + OFFSET(Mipmap,buffer[0]));
+ }
+ else
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ buffer[i] = *Pointer<Pointer<Byte>>(mipmap + OFFSET(Mipmap,buffer) + face[i] * sizeof(void*));
+ }
+ }
+ }
+
+ void SamplerCore::address(Short4 &uuuu, Float4 &uw, AddressingMode addressingMode)
+ {
+ if(addressingMode == ADDRESSING_CLAMP)
+ {
+ Float4 clamp = Min(Max(uw, Float4(0.0f)), Float4(65535.0f / 65536.0f));
+
+ uuuu = Short4(Int4(clamp * Float4(1 << 16)));
+ }
+ else if(addressingMode == ADDRESSING_MIRROR)
+ {
+ Int4 convert = Int4(uw * Float4(1 << 16));
+ Int4 mirror = (convert << 15) >> 31;
+
+ convert ^= mirror;
+
+ uuuu = Short4(convert);
+ }
+ else if(addressingMode == ADDRESSING_MIRRORONCE)
+ {
+ // Absolute value
+ Int4 convert = Int4(Abs(uw * Float4(1 << 16)));
+
+ // Clamp
+ convert -= Int4(0x00008000, 0x00008000, 0x00008000, 0x00008000);
+ convert = As<Int4>(Pack(convert, convert));
+
+ uuuu = As<Short4>(Int2(convert)) + Short4((short)0x8000, (short)0x8000, (short)0x8000, (short)0x8000);
+ }
+ else // Wrap (or border)
+ {
+ uuuu = Short4(Int4(uw * Float4(1 << 16)));
+ }
+ }
+
+ void SamplerCore::convertFixed12(Short4 &ci, Float4 &cf)
+ {
+ ci = RoundShort4(cf * Float4(0x1000, 0x1000, 0x1000, 0x1000));
+ }
+
+ void SamplerCore::convertFixed12(Color4i &ci, Color4f &cf)
+ {
+ convertFixed12(ci.r, cf.r);
+ convertFixed12(ci.g, cf.g);
+ convertFixed12(ci.b, cf.b);
+ convertFixed12(ci.a, cf.a);
+ }
+
+ void SamplerCore::convertSigned12(Float4 &cf, Short4 &ci)
+ {
+ cf = Float4(ci) * Float4(1.0f / 0x0FFE);
+ }
+
+// void SamplerCore::convertSigned12(Color4f &cf, Color4i &ci)
+// {
+// convertSigned12(cf.r, ci.r);
+// convertSigned12(cf.g, ci.g);
+// convertSigned12(cf.b, ci.b);
+// convertSigned12(cf.a, ci.a);
+// }
+
+ void SamplerCore::convertSigned15(Float4 &cf, Short4 &ci)
+ {
+ cf = Float4(ci) * Float4(1.0f / 0x7FFF, 1.0f / 0x7FFF, 1.0f / 0x7FFF, 1.0f / 0x7FFF);
+ }
+
+ void SamplerCore::convertUnsigned16(Float4 &cf, Short4 &ci)
+ {
+ cf = Float4(As<UShort4>(ci)) * Float4(1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF);
+ }
+
+ void SamplerCore::sRGBtoLinear16_12(Short4 &c)
+ {
+ c = As<UShort4>(c) >> 8;
+
+ Pointer<Byte> LUT = Pointer<Byte>(constants + OFFSET(Constants,sRGBtoLinear8));
+
+ c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 0))), 0);
+ c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 1))), 1);
+ c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 2))), 2);
+ c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 3))), 3);
+ }
+
+ bool SamplerCore::hasFloatTexture() const
+ {
+ return Surface::isFloatFormat((Format)state.textureFormat);
+ }
+
+ bool SamplerCore::hasUnsignedTextureComponent(int component) const
+ {
+ return Surface::isUnsignedComponent((Format)state.textureFormat, component);
+ }
+
+ int SamplerCore::textureComponentCount() const
+ {
+ return Surface::componentCount((Format)state.textureFormat);
+ }
+
+ bool SamplerCore::has16bitTexture() const
+ {
+ switch(state.textureFormat)
+ {
+ case FORMAT_G8R8:
+ case FORMAT_X8R8G8B8:
+ case FORMAT_A8R8G8B8:
+ case FORMAT_V8U8:
+ case FORMAT_Q8W8V8U8:
+ case FORMAT_X8L8V8U8:
+ case FORMAT_R32F:
+ case FORMAT_G32R32F:
+ case FORMAT_A32B32G32R32F:
+ case FORMAT_A8:
+ case FORMAT_R8:
+ case FORMAT_L8:
+ case FORMAT_A8L8:
+ case FORMAT_D32F_LOCKABLE:
+ case FORMAT_D32F_TEXTURE:
+ case FORMAT_D32F_SHADOW:
+ return false;
+ case FORMAT_L16:
+ case FORMAT_G16R16:
+ case FORMAT_A16B16G16R16:
+ case FORMAT_V16U16:
+ case FORMAT_A16W16V16U16:
+ case FORMAT_Q16W16V16U16:
+ return true;
+ default:
+ ASSERT(false);
+ }
+
+ return false;
+ }
+
+ bool SamplerCore::isRGBComponent(int component) const
+ {
+ switch(state.textureFormat)
+ {
+ case FORMAT_G8R8: return component < 2;
+ case FORMAT_X8R8G8B8: return component < 3;
+ case FORMAT_A8R8G8B8: return component < 3;
+ case FORMAT_V8U8: return false;
+ case FORMAT_Q8W8V8U8: return false;
+ case FORMAT_X8L8V8U8: return false;
+ case FORMAT_R32F: return component < 1;
+ case FORMAT_G32R32F: return component < 2;
+ case FORMAT_A32B32G32R32F: return component < 3;
+ case FORMAT_A8: return false;
+ case FORMAT_R8: return component < 1;
+ case FORMAT_L8: return component < 1;
+ case FORMAT_A8L8: return component < 1;
+ case FORMAT_D32F_LOCKABLE: return false;
+ case FORMAT_D32F_TEXTURE: return false;
+ case FORMAT_D32F_SHADOW: return false;
+ case FORMAT_L16: return component < 1;
+ case FORMAT_G16R16: return component < 2;
+ case FORMAT_A16B16G16R16: return component < 3;
+ case FORMAT_V16U16: return false;
+ case FORMAT_A16W16V16U16: return false;
+ case FORMAT_Q16W16V16U16: return false;
+ default:
+ ASSERT(false);
+ }
+
+ return false;
+ }
+}
diff --git a/src/Shader/SamplerCore.hpp b/src/Shader/SamplerCore.hpp
new file mode 100644
index 0000000..c3c11e9
--- /dev/null
+++ b/src/Shader/SamplerCore.hpp
@@ -0,0 +1,69 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_SamplerCore_hpp
+#define sw_SamplerCore_hpp
+
+#include "PixelRoutine.hpp"
+#include "Reactor/Nucleus.hpp"
+
+namespace sw
+{
+ class SamplerCore
+ {
+ public:
+ SamplerCore(Pointer<Byte> &r, const Sampler::State &state);
+
+ void sampleTexture(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool bias = false, bool fixed12 = true, bool gradients = false, bool lodProvided = false);
+ void sampleTexture(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Color4f &dsx, Color4f &dsy, bool bias = false, bool gradients = false, bool lodProvided = false);
+
+ private:
+ void border(Short4 &mask, Float4 &coordinates);
+ void border(Int4 &mask, Float4 &coordinates);
+ Short4 offsetSample(Short4 &uvw, Pointer<Byte> &mipmap, int halfOffset, bool wrap, int count);
+ void sampleFilter(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool lodProvided);
+ void sampleAniso(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, bool lodProvided);
+ void sampleQuad(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Int face[4], bool secondLOD);
+ void sampleQuad2D(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float &lod, Int face[4], bool secondLOD);
+ void sample3D(Pointer<Byte> &texture, Color4i &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, bool secondLOD);
+ void sampleFloatFilter(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool lodProvided);
+ void sampleFloatAniso(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, bool lodProvided);
+ void sampleFloat(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, Int face[4], bool secondLOD);
+ void sampleFloat2D(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &z, Float &lod, Int face[4], bool secondLOD);
+ void sampleFloat3D(Pointer<Byte> &texture, Color4f &c, Float4 &u, Float4 &v, Float4 &w, Float &lod, bool secondLOD);
+ void computeLod(Pointer<Byte> &texture, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Float4 &u, Float4 &v, Float &lodBias, Color4f &dsx, Color4f &dsy, bool bias, bool gradients, bool lodProvided);
+ void computeLod3D(Pointer<Byte> &texture, Float &lod, Float4 &u, Float4 &v, Float4 &w, Float &lodBias, Color4f &dsx, Color4f &dsy, bool bias, bool gradients, bool lodProvided);
+ void cubeFace(Int face[4], Float4 &U, Float4 &V, Float4 &lodU, Float4 &lodV, Float4 &x, Float4 &y, Float4 &z);
+ void computeIndices(Int index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, const Pointer<Byte> &mipmap);
+ void sampleTexel(Color4i &c, Short4 &u, Short4 &v, Short4 &s, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4]);
+ void sampleTexel(Color4f &c, Short4 &u, Short4 &v, Short4 &s, Float4 &z, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4]);
+ void selectMipmap(Pointer<Byte> &texture, Pointer<Byte> buffer[4], Pointer<Byte> &mipmap, Float &lod, Int face[4], bool secondLOD);
+ void address(Short4 &uuuu, Float4 &uw, AddressingMode addressingMode);
+
+ void convertFixed12(Short4 &ci, Float4 &cf);
+ void convertFixed12(Color4i &ci, Color4f &cf);
+ void convertSigned12(Float4 &cf, Short4 &ci);
+ void convertSigned15(Float4 &cf, Short4 &ci);
+ void convertUnsigned16(Float4 &cf, Short4 &ci);
+ void sRGBtoLinear16_12(Short4 &c);
+
+ bool hasFloatTexture() const;
+ bool hasUnsignedTextureComponent(int component) const;
+ int textureComponentCount() const;
+ bool has16bitTexture() const;
+ bool isRGBComponent(int component) const;
+
+ Pointer<Byte> &constants;
+ const Sampler::State &state;
+ };
+}
+
+#endif // sw_SamplerCore_hpp
diff --git a/src/Shader/SetupRoutine.cpp b/src/Shader/SetupRoutine.cpp
new file mode 100644
index 0000000..40a2a18
--- /dev/null
+++ b/src/Shader/SetupRoutine.cpp
@@ -0,0 +1,661 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "SetupRoutine.hpp"
+
+#include "Constants.hpp"
+#include "Renderer/Primitive.hpp"
+#include "Renderer/Polygon.hpp"
+#include "Renderer/Renderer.hpp"
+#include "Reactor/Shell.hpp"
+
+namespace sw
+{
+ extern bool complementaryDepthBuffer;
+ extern TranscendentalPrecision logPrecision;
+
+ SetupRoutine::SetupRoutine(const SetupProcessor::State &state) : state(state)
+ {
+ routine = 0;
+ }
+
+ SetupRoutine::~SetupRoutine()
+ {
+ }
+
+ void SetupRoutine::generate()
+ {
+ Function<Bool, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>> function;
+ {
+ Pointer<Byte> primitive(function.arg(0));
+ Pointer<Byte> tri(function.arg(1));
+ Pointer<Byte> polygon(function.arg(2));
+ Pointer<Byte> data(function.arg(3));
+
+ Pointer<Byte> constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
+
+ const bool point = state.isDrawPoint;
+ const bool sprite = state.pointSprite;
+ const bool line = state.isDrawLine;
+ const bool triangle = state.isDrawSolidTriangle || sprite;
+ const bool solidTriangle = state.isDrawSolidTriangle;
+
+ const int V0 = OFFSET(Triangle,v0);
+ const int V1 = (triangle || line) ? OFFSET(Triangle,v1) : OFFSET(Triangle,v0);
+ const int V2 = triangle ? OFFSET(Triangle,v2) : (line ? OFFSET(Triangle,v1) : OFFSET(Triangle,v0));
+
+ int pos = state.positionRegister;
+
+ Pointer<Byte> v0 = tri + V0;
+ Pointer<Byte> v1 = tri + V1;
+ Pointer<Byte> v2 = tri + V2;
+
+ Array<Int> X(16);
+ Array<Int> Y(16);
+
+ X[0] = *Pointer<Int>(v0 + OFFSET(Vertex,X));
+ X[1] = *Pointer<Int>(v1 + OFFSET(Vertex,X));
+ X[2] = *Pointer<Int>(v2 + OFFSET(Vertex,X));
+
+ Y[0] = *Pointer<Int>(v0 + OFFSET(Vertex,Y));
+ Y[1] = *Pointer<Int>(v1 + OFFSET(Vertex,Y));
+ Y[2] = *Pointer<Int>(v2 + OFFSET(Vertex,Y));
+
+ Int d = 1; // Winding direction
+
+ // Culling
+ if(solidTriangle)
+ {
+ Float x0 = Float(X[0]);
+ Float x1 = Float(X[1]);
+ Float x2 = Float(X[2]);
+
+ Float y0 = Float(Y[0]);
+ Float y1 = Float(Y[1]);
+ Float y2 = Float(Y[2]);
+
+ Float A = (y2 - y0) * x1 + (y1 - y2) * x0 + (y0 - y1) * x2; // Area
+
+ If(A == Float(0.0f))
+ {
+ Return(false);
+ }
+
+ Float w0w1w2 = *Pointer<Float>(v0 + pos * 16 + 12) *
+ *Pointer<Float>(v1 + pos * 16 + 12) *
+ *Pointer<Float>(v2 + pos * 16 + 12);
+
+ A = IfThenElse(w0w1w2 < Float(0.0f), -A, A);
+
+ if(state.cullMode == Context::CULL_CLOCKWISE)
+ {
+ If(A >= Float(0.0f)) Return(false);
+ }
+ else if(state.cullMode == Context::CULL_COUNTERCLOCKWISE)
+ {
+ If(A <= Float(0.0f)) Return(false);
+ }
+
+ d = IfThenElse(A < Float(0.0f), d, Int(0));
+
+ if(state.twoSidedStencil)
+ {
+ Byte8 clockwiseMask = IfThenElse(A > Float(0.0f), Byte8(0xFFFFFFFFFFFFFFFF), Byte8(0x0000000000000000));
+
+ *Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = clockwiseMask;
+ *Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = ~clockwiseMask;
+ }
+
+ if(state.vFace)
+ {
+ *Pointer<Float>(primitive + OFFSET(Primitive,area)) = Float(0.5f) * A;
+ }
+ }
+ else
+ {
+ if(state.twoSidedStencil)
+ {
+ *Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = Byte8(0xFFFFFFFFFFFFFFFF);
+ *Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = Byte8(0x0000000000000000);
+ }
+ }
+
+ Int n = *Pointer<Int>(polygon + OFFSET(Polygon,n));
+ Int m = *Pointer<Int>(polygon + OFFSET(Polygon,i));
+
+ If(m != 0 || Bool(!solidTriangle)) // Clipped triangle; reproject
+ {
+ Pointer<Byte> V = polygon + OFFSET(Polygon,P) + m * sizeof(void*) * 16;
+
+ Int i = 0;
+
+ Do
+ {
+ Pointer<Float4> p = *Pointer<Pointer<Float4>>(V + i * sizeof(void*));
+ Float4 v = *Pointer<Float4>(p, 16);
+
+ Float w = v.w;
+ Float rhw = IfThenElse(w != Float(0.0f), Float(1.0f) / w, Float(1.0f));
+
+ X[i] = RoundInt(*Pointer<Float>(data + OFFSET(DrawData,LLLLx16)) + v.x * rhw * *Pointer<Float>(data + OFFSET(DrawData,WWWWx16)));
+ Y[i] = RoundInt(*Pointer<Float>(data + OFFSET(DrawData,TTTTx16)) + v.y * rhw * *Pointer<Float>(data + OFFSET(DrawData,HHHHx16)));
+
+ i++;
+ }
+ Until(i >= n)
+ }
+
+ // Vertical range
+ Int yMin = Y[0];
+ Int yMax = Y[0];
+
+ Int i = 1;
+
+ Do
+ {
+ yMin = IfThenElse(Y[i] < yMin, Int(Y[i]), yMin); // FIXME: Min(Y[i], yMin)
+ yMax = IfThenElse(Y[i] > yMax, Int(Y[i]), yMax); // FIXME: Max(Y[i], yMax)
+
+ i++;
+ }
+ Until(i >= n)
+
+ if(state.multiSample > 1)
+ {
+ yMin = (yMin + 0x0A) >> 4;
+ yMax = (yMax + 0x14) >> 4;
+ }
+ else
+ {
+ yMin = (yMin + 0x0F) >> 4;
+ yMax = (yMax + 0x0F) >> 4;
+ }
+
+ If(yMin == yMax)
+ {
+ Return(false);
+ }
+
+ For(Int q = 0, q < state.multiSample, q++)
+ {
+ Array<Int> Xq(16);
+ Array<Int> Yq(16);
+
+ Int i = 0;
+
+ Do
+ {
+ Xq[i] = X[i];
+ Yq[i] = Y[i];
+
+ if(state.multiSample > 1)
+ {
+ Xq[i] = Xq[i] + *Pointer<Int>(constants + OFFSET(Constants,Xf) + q * sizeof(int));
+ Yq[i] = Yq[i] + *Pointer<Int>(constants + OFFSET(Constants,Yf) + q * sizeof(int));
+ }
+
+ i++;
+ }
+ Until(i >= n)
+
+ Pointer<Byte> leftEdge = Pointer<Byte>(primitive + OFFSET(Primitive,outline->left)) + q * sizeof(Primitive);
+ Pointer<Byte> rightEdge = Pointer<Byte>(primitive + OFFSET(Primitive,outline->right)) + q * sizeof(Primitive);
+
+ if(state.multiSample > 1)
+ {
+ Short x = Short((X[0] + 0xF) >> 4);
+
+ For(Int y = yMin - 1, y < yMax + 1, y++)
+ {
+ *Pointer<Short>(leftEdge + y * sizeof(Primitive::Span)) = x;
+ *Pointer<Short>(rightEdge + y * sizeof(Primitive::Span)) = x;
+ }
+ }
+
+ Xq[n] = Xq[0];
+ Yq[n] = Yq[0];
+
+ // Rasterize
+ {
+ Int i = 0;
+
+ Do
+ {
+ edge(primitive, Int(Xq[i + 1 - d]), Int(Yq[i + 1 - d]), Int(Xq[i + d]), Int(Yq[i + d]), q);
+
+ i++;
+ }
+ Until(i >= n)
+ }
+
+ if(state.multiSample == 1)
+ {
+ For(yMin, yMin < yMax && *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span)) == *Pointer<Short>(rightEdge + yMin * sizeof(Primitive::Span)), yMin++)
+ {
+ // Increments yMin
+ }
+
+ For(yMax, yMax > yMin && *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span)) == *Pointer<Short>(rightEdge + (yMax - 1) * sizeof(Primitive::Span)), yMax--)
+ {
+ // Decrements yMax
+ }
+
+ If(yMin == yMax)
+ {
+ Return(false);
+ }
+
+ *Pointer<Short>(leftEdge + (yMin - 1) * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span));
+ *Pointer<Short>(rightEdge + (yMin - 1) * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span));
+ *Pointer<Short>(leftEdge + yMax * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span));
+ *Pointer<Short>(rightEdge + yMax * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span));
+ }
+ }
+
+ *Pointer<Int>(primitive + OFFSET(Primitive,yMin)) = yMin;
+ *Pointer<Int>(primitive + OFFSET(Primitive,yMax)) = yMax;
+
+ // Sort by minimum y
+ if(solidTriangle && logPrecision >= WHQL)
+ {
+ Float y0 = *Pointer<Float>(v0 + pos * 16 + 4);
+ Float y1 = *Pointer<Float>(v1 + pos * 16 + 4);
+ Float y2 = *Pointer<Float>(v2 + pos * 16 + 4);
+
+ Float yMin = Min(Min(y0, y1), y2);
+
+ conditionalRotate1(yMin == y1, v0, v1, v2);
+ conditionalRotate2(yMin == y2, v0, v1, v2);
+ }
+
+ // Sort by maximum w
+ if(solidTriangle)
+ {
+ Float w0 = *Pointer<Float>(v0 + pos * 16 + 12);
+ Float w1 = *Pointer<Float>(v1 + pos * 16 + 12);
+ Float w2 = *Pointer<Float>(v2 + pos * 16 + 12);
+
+ Float wMax = Max(Max(w0, w1), w2);
+
+ conditionalRotate1(wMax == w1, v0, v1, v2);
+ conditionalRotate2(wMax == w2, v0, v1, v2);
+ }
+
+ Float4 p0 = *Pointer<Float4>(v0 + pos * 16, 16);
+ Float4 p1 = *Pointer<Float4>(v1 + pos * 16, 16);
+ Float4 p2 = *Pointer<Float4>(v2 + pos * 16, 16);
+
+ Float w0 = p0.w;
+ Float w1 = p1.w;
+ Float w2 = p2.w;
+
+ Float4 w012;
+
+ w012.x = w0;
+ w012.y = w1;
+ w012.z = w2;
+ w012.w = 1;
+
+ Float rhw0 = *Pointer<Float>(v0 + OFFSET(Vertex,W));
+
+ Int X0 = *Pointer<Int>(v0 + OFFSET(Vertex,X));
+ Int X1 = *Pointer<Int>(v1 + OFFSET(Vertex,X));
+ Int X2 = *Pointer<Int>(v2 + OFFSET(Vertex,X));
+
+ Int Y0 = *Pointer<Int>(v0 + OFFSET(Vertex,Y));
+ Int Y1 = *Pointer<Int>(v1 + OFFSET(Vertex,Y));
+ Int Y2 = *Pointer<Int>(v2 + OFFSET(Vertex,Y));
+
+ if(line)
+ {
+ X2 = X1 + Y1 - Y0;
+ Y2 = Y1 + X0 - X1;
+ }
+
+ Float dx = Float(X0) * Float(1.0f / 16.0f);
+ Float dy = Float(Y0) * Float(1.0f / 16.0f);
+
+ X1 -= X0;
+ Y1 -= Y0;
+
+ X2 -= X0;
+ Y2 -= Y0;
+
+ Float x1 = w1 * Float(1.0f / 16.0f) * Float(X1);
+ Float y1 = w1 * Float(1.0f / 16.0f) * Float(Y1);
+
+ Float x2 = w2 * Float(1.0f / 16.0f) * Float(X2);
+ Float y2 = w2 * Float(1.0f / 16.0f) * Float(Y2);
+
+ Float a = x1 * y2 - x2 * y1;
+
+ Float4 xQuad = Float4(0, 1, 0, 1) - Float4(dx);
+ Float4 yQuad = Float4(0, 0, 1, 1) - Float4(dy);
+
+ *Pointer<Float4>(primitive + OFFSET(Primitive,xQuad), 16) = xQuad;
+ *Pointer<Float4>(primitive + OFFSET(Primitive,yQuad), 16) = yQuad;
+
+ Float4 M[3];
+
+ M[0] = Float4(0, 0, 0, 0);
+ M[1] = Float4(0, 0, 0, 0);
+ M[2] = Float4(0, 0, 0, 0);
+
+ M[0].z = rhw0;
+
+ If(a != Float(0.0f))
+ {
+ Float A = Float(1) / a;
+ Float D = A * rhw0;
+
+ M[0].x = (y1 * w2 - y2 * w1) * D;
+ M[0].y = (x2 * w1 - x1 * w2) * D;
+ // M[0].z = rhw0;
+ // M[0].w = 0;
+
+ M[1].x = y2 * A;
+ M[1].y = -x2 * A;
+ // M[1].z = 0;
+ // M[1].w = 0;
+
+ M[2].x = -y1 * A;
+ M[2].y = x1 * A;
+ // M[2].z = 0;
+ // M[2].w = 0;
+ }
+
+ if(state.perspective)
+ {
+ Float4 ABC = M[0] + M[1] + M[2];
+
+ Float4 A = ABC.x;
+ Float4 B = ABC.y;
+ Float4 C = ABC.z;
+
+ *Pointer<Float4>(primitive + OFFSET(Primitive,w.A), 16) = A;
+ *Pointer<Float4>(primitive + OFFSET(Primitive,w.B), 16) = B;
+ *Pointer<Float4>(primitive + OFFSET(Primitive,w.C), 16) = C;
+ }
+
+ if(state.interpolateDepth)
+ {
+ Float z0 = *Pointer<Float>(v0 + OFFSET(Vertex,Z));
+ Float z1 = *Pointer<Float>(v1 + OFFSET(Vertex,Z));
+ Float z2 = *Pointer<Float>(v2 + OFFSET(Vertex,Z));
+
+ z1 -= z0;
+ z2 -= z0;
+
+ Float4 A;
+ Float4 B;
+ Float4 C;
+
+ if(!point)
+ {
+ Float x1 = Float(X1) * Float(1.0f / 16.0f);
+ Float y1 = Float(Y1) * Float(1.0f / 16.0f);
+ Float x2 = Float(X2) * Float(1.0f / 16.0f);
+ Float y2 = Float(Y2) * Float(1.0f / 16.0f);
+
+ Float D = *Pointer<Float>(data + OFFSET(DrawData,depthRange)) / (x1 * y2 - x2 * y1);
+
+ Float a = (y2 * z1 - y1 * z2) * D;
+ Float b = (x1 * z2 - x2 * z1) * D;
+
+ A = Float4(a);
+ B = Float4(b);
+ }
+ else
+ {
+ A = Float4(0, 0, 0, 0);
+ B = Float4(0, 0, 0, 0);
+ }
+
+ *Pointer<Float4>(primitive + OFFSET(Primitive,z.A), 16) = A;
+ *Pointer<Float4>(primitive + OFFSET(Primitive,z.B), 16) = B;
+
+ Float c = z0;
+
+ if(state.isDrawTriangle && state.slopeDepthBias)
+ {
+ Float bias = Max(Abs(Float(A.x)), Abs(Float(B.x)));
+ bias *= *Pointer<Float>(data + OFFSET(DrawData,slopeDepthBias));
+
+ if(complementaryDepthBuffer)
+ {
+ bias = -bias;
+ }
+
+ c += bias;
+ }
+
+ C = Float4(c * *Pointer<Float>(data + OFFSET(DrawData,depthRange)) + *Pointer<Float>(data + OFFSET(DrawData,depthNear)));
+
+ *Pointer<Float4>(primitive + OFFSET(Primitive,z.C), 16) = C;
+ }
+
+ for(int interpolant = 0; interpolant < 11; interpolant++)
+ {
+ int componentCount = interpolant < 10 ? 4 : 1; // Fog only has one component
+
+ for(int component = 0; component < componentCount; component++)
+ {
+ int attribute = state.gradient[interpolant][component].attribute;
+ bool flat = state.gradient[interpolant][component].flat;
+ bool wrap = state.gradient[interpolant][component].wrap;
+
+ if(attribute < 12)
+ {
+ setupGradient(primitive, tri, w012, M, v0, v1, v2, OFFSET(Vertex,v[attribute][component]), OFFSET(Primitive,V[interpolant][component]), flat, sprite, state.perspective, wrap, component);
+ }
+ }
+ }
+
+ Return(true);
+ }
+
+ routine = function(L"SetupRoutine");
+ }
+
+ void SetupRoutine::setupGradient(Pointer<Byte> &primitive, Pointer<Byte> &triangle, Float4 &w012, Float4 (&m)[3], Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2, int attribute, int planeEquation, bool flat, bool sprite, bool perspective, bool wrap, int component)
+ {
+ Float4 i;
+
+ if(!flat)
+ {
+ if(!sprite)
+ {
+ i.x = *Pointer<Float>(v0 + attribute);
+ i.y = *Pointer<Float>(v1 + attribute);
+ i.z = *Pointer<Float>(v2 + attribute);
+ i.w = 0;
+ }
+ else
+ {
+ if(component == 0) i.x = Float(0.5f);
+ if(component == 1) i.x = Float(0.5f);
+ if(component == 2) i.x = Float(0.0f);
+ if(component == 3) i.x = Float(1.0f);
+
+ if(component == 0) i.y = Float(1.0f);
+ if(component == 1) i.y = Float(0.5f);
+ if(component == 2) i.y = Float(0.0f);
+ if(component == 3) i.y = Float(1.0f);
+
+ if(component == 0) i.z = Float(0.5f);
+ if(component == 1) i.z = Float(0.0f);
+ if(component == 2) i.z = Float(0.0f);
+ if(component == 3) i.z = Float(1.0f);
+
+ i.w = 0;
+ }
+
+ if(wrap)
+ {
+ Float m;
+
+ m = *Pointer<Float>(v0 + attribute);
+ m = Max(m, *Pointer<Float>(v1 + attribute));
+ m = Max(m, *Pointer<Float>(v2 + attribute));
+ m -= Float(0.5f); // FIXME: m -= 0.5f;
+
+ // FIXME: Vectorize
+ If(Float(i.x) < m) i.x = Float(i.x) + Float(1.0f);
+ If(Float(i.y) < m) i.y = Float(i.y) + Float(1.0f);
+ If(Float(i.z) < m) i.z = Float(i.z) + Float(1.0f);
+ }
+
+ if(!perspective)
+ {
+ i *= w012;
+ }
+
+ Float4 A;
+ Float4 B;
+ Float4 C;
+
+ A = i.xxxx;
+ B = i.yyyy;
+ C = i.zzzz;
+
+ A *= m[0];
+ B *= m[1];
+ C *= m[2];
+
+ C = A + B + C;
+
+ A = C.xxxx;
+ B = C.yyyy;
+ C = C.zzzz;
+
+ *Pointer<Float4>(primitive + planeEquation + 0, 16) = A;
+ *Pointer<Float4>(primitive + planeEquation + 16, 16) = B;
+ *Pointer<Float4>(primitive + planeEquation + 32, 16) = C;
+ }
+ else
+ {
+ Float C = *Pointer<Float>(triangle + OFFSET(Triangle,v0) + attribute);
+
+ *Pointer<Float4>(primitive + planeEquation + 0, 16) = Float4(0, 0, 0, 0);
+ *Pointer<Float4>(primitive + planeEquation + 16, 16) = Float4(0, 0, 0, 0);
+ *Pointer<Float4>(primitive + planeEquation + 32, 16) = Float4(C);
+ }
+ }
+
+ void SetupRoutine::edge(Pointer<Byte> &primitive, Int &X1, Int &Y1, Int &X2, Int &Y2, Int &q)
+ {
+ If(Y1 != Y2)
+ {
+ Bool swap = Y2 < Y1;
+
+ Pointer<Byte> leftEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->left);
+ Pointer<Byte> rightEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->right);
+ Pointer<Byte> edge = IfThenElse(swap, rightEdge, leftEdge);
+
+ Int X0 = X1;
+ Int Y0 = Y1;
+ X1 = IfThenElse(swap, X2, X1);
+ X2 = IfThenElse(swap, X0, X2);
+ Y1 = IfThenElse(swap, Y2, Y1);
+ Y2 = IfThenElse(swap, Y0, Y2);
+
+ Int y1 = (Y1 + 0x0000000F) >> 4;
+ Int y2 = (Y2 + 0x0000000F) >> 4;
+
+ If(y1 != y2)
+ {
+ // Deltas
+ Int DX12 = X2 - X1;
+ Int DY12 = Y2 - Y1;
+
+ Int FDX12 = DX12 << 4;
+ Int FDY12 = DY12 << 4;
+
+ Int X = DX12 * (-Y1 & 0xF) + X1 * DY12;
+ Int x = X / FDY12; // Edge
+ Int d = X % FDY12; // Error-term
+ Int ceil = -d >> 31; // Ceiling division: remainder <= 0
+ x -= ceil;
+ d -= ceil & FDY12;
+
+ Int Q = FDX12 / FDY12; // Edge-step
+ Int R = FDX12 % FDY12; // Error-step
+ Int floor = R >> 31; // Flooring division: remainder >= 0
+ Q += floor;
+ R += floor & FDY12;
+
+ Int D = FDY12; // Error-overflow
+ Int y = y1;
+
+ Do
+ {
+ *Pointer<Short>(edge + y * sizeof(Primitive::Span)) = Short(x);
+
+ x += Q;
+ d += R;
+
+ Int overflow = -d >> 31;
+
+ d -= D & overflow;
+ x -= overflow;
+
+ y++;
+ }
+ Until(y >= y2)
+ }
+ }
+ }
+
+ void SetupRoutine::conditionalRotate1(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2)
+ {
+ #if 0 // Rely on LLVM optimization
+ If(condition)
+ {
+ Pointer<Byte> vX;
+
+ vX = v0;
+ v0 = v1;
+ v1 = v2;
+ v2 = vX;
+ }
+ #else
+ Pointer<Byte> vX = v0;
+ v0 = IfThenElse(condition, v1, v0);
+ v1 = IfThenElse(condition, v2, v1);
+ v2 = IfThenElse(condition, vX, v2);
+ #endif
+ }
+
+ void SetupRoutine::conditionalRotate2(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2)
+ {
+ #if 0 // Rely on LLVM optimization
+ If(condition)
+ {
+ Pointer<Byte> vX;
+
+ vX = v2;
+ v2 = v1;
+ v1 = v0;
+ v0 = vX;
+ }
+ #else
+ Pointer<Byte> vX = v2;
+ v2 = IfThenElse(condition, v1, v2);
+ v1 = IfThenElse(condition, v0, v1);
+ v0 = IfThenElse(condition, vX, v0);
+ #endif
+ }
+
+ Routine *SetupRoutine::getRoutine()
+ {
+ return routine;
+ }
+}
diff --git a/src/Shader/SetupRoutine.hpp b/src/Shader/SetupRoutine.hpp
new file mode 100644
index 0000000..cf40281
--- /dev/null
+++ b/src/Shader/SetupRoutine.hpp
@@ -0,0 +1,44 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_SetupRoutine_hpp
+#define sw_SetupRoutine_hpp
+
+#include "SetupProcessor.hpp"
+#include "Reactor/Nucleus.hpp"
+
+namespace sw
+{
+ class Context;
+
+ class SetupRoutine
+ {
+ public:
+ SetupRoutine(const SetupProcessor::State &state);
+
+ virtual ~SetupRoutine();
+
+ void generate();
+ Routine *getRoutine();
+
+ private:
+ void setupGradient(Pointer<Byte> &primitive, Pointer<Byte> &triangle, Float4 &w012, Float4 (&m)[3], Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2, int attribute, int planeEquation, bool flatShading, bool sprite, bool perspective, bool wrap, int component);
+ void edge(Pointer<Byte> &primitive, Int &X1, Int &Y1, Int &X2, Int &Y2, Int &q);
+ void conditionalRotate1(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2);
+ void conditionalRotate2(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2);
+
+ const SetupProcessor::State &state;
+
+ Routine *routine;
+ };
+}
+
+#endif // sw_SetupRoutine_hpp
diff --git a/src/Shader/Shader.cpp b/src/Shader/Shader.cpp
new file mode 100644
index 0000000..43e8bdc
--- /dev/null
+++ b/src/Shader/Shader.cpp
@@ -0,0 +1,1318 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "Shader.hpp"
+
+#include "Math.hpp"
+#include "Debug.hpp"
+
+#include <stdarg.h>
+#include <fstream>
+#include <sstream>
+
+namespace sw
+{
+ Shader::Instruction::Instruction()
+ {
+ operation.opcode = Operation::OPCODE_NOP;
+ destinationParameter.type = Parameter::PARAMETER_VOID;
+ sourceParameter[0].type = Parameter::PARAMETER_VOID;
+ sourceParameter[1].type = Parameter::PARAMETER_VOID;
+ sourceParameter[2].type = Parameter::PARAMETER_VOID;
+ sourceParameter[3].type = Parameter::PARAMETER_VOID;
+ }
+
+ Shader::Instruction::Instruction(const unsigned long *token, int size, unsigned char majorVersion)
+ {
+ parseOperationToken(*token++, majorVersion);
+
+ if(operation.opcode == Operation::OPCODE_IF ||
+ operation.opcode == Operation::OPCODE_IFC ||
+ operation.opcode == Operation::OPCODE_LOOP ||
+ operation.opcode == Operation::OPCODE_REP ||
+ operation.opcode == Operation::OPCODE_BREAKC ||
+ operation.opcode == Operation::OPCODE_BREAKP) // No destination operand
+ {
+ if(size > 0) parseSourceToken(0, token++, majorVersion);
+ if(size > 1) parseSourceToken(1, token++, majorVersion);
+ if(size > 2) parseSourceToken(2, token++, majorVersion);
+ if(size > 3) ASSERT(false);
+ }
+ else if(operation.opcode == Operation::OPCODE_DCL)
+ {
+ parseDeclarationToken(*token++);
+ parseDestinationToken(token++, majorVersion);
+ }
+ else
+ {
+ if(size > 0)
+ {
+ parseDestinationToken(token, majorVersion);
+
+ if(destinationParameter.relative && majorVersion >= 3)
+ {
+ token++;
+ size--;
+ }
+
+ token++;
+ size--;
+ }
+
+ if(operation.predicate)
+ {
+ ASSERT(size != 0);
+
+ operation.predicateNot = (SourceParameter::Modifier)((*token & 0x0F000000) >> 24) == SourceParameter::MODIFIER_NOT;
+ operation.predicateSwizzle = (unsigned char)((*token & 0x00FF0000) >> 16);
+
+ token++;
+ size--;
+ }
+
+ for(int i = 0; size > 0; i++)
+ {
+ parseSourceToken(i, token, majorVersion);
+
+ token++;
+ size--;
+
+ if(sourceParameter[i].relative && majorVersion >= 2)
+ {
+ token++;
+ size--;
+ }
+ }
+ }
+ }
+
+ Shader::Instruction::~Instruction()
+ {
+ }
+
+ Shader::Instruction::Operation::Opcode Shader::Instruction::getOpcode() const
+ {
+ return operation.opcode;
+ }
+
+ const Shader::Instruction::DestinationParameter &Shader::Instruction::getDestinationParameter() const
+ {
+ return destinationParameter;
+ }
+
+ const Shader::Instruction::SourceParameter &Shader::Instruction::getSourceParameter(int i) const
+ {
+ return sourceParameter[i];
+ }
+
+ bool Shader::Instruction::isCoissue() const
+ {
+ return operation.coissue;
+ }
+
+ bool Shader::Instruction::isProject() const
+ {
+ return operation.project;
+ }
+
+ bool Shader::Instruction::isBias() const
+ {
+ return operation.bias;
+ }
+
+ bool Shader::Instruction::isPredicate() const
+ {
+ return operation.predicate;
+ }
+
+ bool Shader::Instruction::isPredicateNot() const
+ {
+ return operation.predicateNot;
+ }
+
+ unsigned char Shader::Instruction::getPredicateSwizzle() const
+ {
+ return operation.predicateSwizzle;
+ }
+
+ Shader::Instruction::Operation::Control Shader::Instruction::getControl() const
+ {
+ return operation.control;
+ }
+
+ Shader::Instruction::Operation::Usage Shader::Instruction::getUsage() const
+ {
+ return operation.usage;
+ }
+
+ unsigned char Shader::Instruction::getUsageIndex() const
+ {
+ return operation.usageIndex;
+ }
+
+ Shader::Instruction::Operation::SamplerType Shader::Instruction::getSamplerType() const
+ {
+ return operation.samplerType;
+ }
+
+ std::string Shader::Instruction::string(ShaderType shaderType, unsigned short version) const
+ {
+ std::string instructionString;
+
+ if(operation.opcode != Operation::OPCODE_DCL)
+ {
+ instructionString += operation.coissue ? "+ " : "";
+
+ if(operation.predicate)
+ {
+ instructionString += operation.predicateNot ? "(!p0" : "(p0";
+ instructionString += swizzleString(Parameter::PARAMETER_PREDICATE, operation.predicateSwizzle);
+ instructionString += ") ";
+ }
+
+ instructionString += operation.string(version) + operation.controlString() + destinationParameter.shiftString() + destinationParameter.modifierString();
+
+ if(destinationParameter.type != Parameter::PARAMETER_VOID)
+ {
+ instructionString += " " + destinationParameter.string(shaderType, version) +
+ destinationParameter.relativeString() +
+ destinationParameter.maskString();
+ }
+
+ for(int i = 0; i < 4; i++)
+ {
+ if(sourceParameter[i].type != Parameter::PARAMETER_VOID)
+ {
+ instructionString += (destinationParameter.type != Parameter::PARAMETER_VOID || i > 0) ? ", " : " ";
+ instructionString += sourceParameter[i].preModifierString() +
+ sourceParameter[i].string(shaderType, version) +
+ sourceParameter[i].relativeString() +
+ sourceParameter[i].postModifierString() +
+ sourceParameter[i].swizzleString();
+ }
+ }
+ }
+ else // DCL
+ {
+ instructionString += "dcl";
+
+ if(destinationParameter.type == Parameter::PARAMETER_SAMPLER)
+ {
+ switch(operation.samplerType)
+ {
+ case Operation::SAMPLER_UNKNOWN: instructionString += " "; break;
+ case Operation::SAMPLER_1D: instructionString += "_1d "; break;
+ case Operation::SAMPLER_2D: instructionString += "_2d "; break;
+ case Operation::SAMPLER_CUBE: instructionString += "_cube "; break;
+ case Operation::SAMPLER_VOLUME: instructionString += "_volume "; break;
+ default:
+ ASSERT(false);
+ }
+
+ instructionString += destinationParameter.string(shaderType, version);
+ }
+ else if(destinationParameter.type == Parameter::PARAMETER_INPUT ||
+ destinationParameter.type == Parameter::PARAMETER_OUTPUT ||
+ destinationParameter.type == Parameter::PARAMETER_TEXTURE)
+ {
+ if(version >= 0x0300)
+ {
+ switch(operation.usage)
+ {
+ case Operation::USAGE_POSITION: instructionString += "_position"; break;
+ case Operation::USAGE_BLENDWEIGHT: instructionString += "_blendweight"; break;
+ case Operation::USAGE_BLENDINDICES: instructionString += "_blendindices"; break;
+ case Operation::USAGE_NORMAL: instructionString += "_normal"; break;
+ case Operation::USAGE_PSIZE: instructionString += "_psize"; break;
+ case Operation::USAGE_TEXCOORD: instructionString += "_texcoord"; break;
+ case Operation::USAGE_TANGENT: instructionString += "_tangent"; break;
+ case Operation::USAGE_BINORMAL: instructionString += "_binormal"; break;
+ case Operation::USAGE_TESSFACTOR: instructionString += "_tessfactor"; break;
+ case Operation::USAGE_POSITIONT: instructionString += "_positiont"; break;
+ case Operation::USAGE_COLOR: instructionString += "_color"; break;
+ case Operation::USAGE_FOG: instructionString += "_fog"; break;
+ case Operation::USAGE_DEPTH: instructionString += "_depth"; break;
+ case Operation::USAGE_SAMPLE: instructionString += "_sample"; break;
+ default:
+ ASSERT(false);
+ }
+
+ if(operation.usageIndex > 0)
+ {
+ std::ostringstream buffer;
+
+ buffer << (int)operation.usageIndex;
+
+ instructionString += buffer.str();
+ }
+ }
+ else ASSERT(destinationParameter.type != Parameter::PARAMETER_OUTPUT);
+
+ instructionString += " ";
+
+ instructionString += destinationParameter.string(shaderType, version);
+ instructionString += destinationParameter.maskString();
+ }
+ else if(destinationParameter.type == Parameter::PARAMETER_MISCTYPE) // vPos and vFace
+ {
+ instructionString += " ";
+
+ instructionString += destinationParameter.string(shaderType, version);
+ }
+ else ASSERT(false);
+ }
+
+ return instructionString;
+ }
+
+ std::string Shader::Instruction::Operation::string(unsigned short version) const
+ {
+ switch(opcode)
+ {
+ case OPCODE_NOP: return "nop";
+ case OPCODE_MOV: return "mov";
+ case OPCODE_ADD: return "add";
+ case OPCODE_SUB: return "sub";
+ case OPCODE_MAD: return "mad";
+ case OPCODE_MUL: return "mul";
+ case OPCODE_RCP: return "rcp";
+ case OPCODE_RSQ: return "rsq";
+ case OPCODE_DP3: return "dp3";
+ case OPCODE_DP4: return "dp4";
+ case OPCODE_MIN: return "min";
+ case OPCODE_MAX: return "max";
+ case OPCODE_SLT: return "slt";
+ case OPCODE_SGE: return "sge";
+ case OPCODE_EXP: return "exp";
+ case OPCODE_LOG: return "log";
+ case OPCODE_LIT: return "lit";
+ case OPCODE_DST: return "dst";
+ case OPCODE_LRP: return "lrp";
+ case OPCODE_FRC: return "frc";
+ case OPCODE_M4X4: return "m4x4";
+ case OPCODE_M4X3: return "m4x3";
+ case OPCODE_M3X4: return "m3x4";
+ case OPCODE_M3X3: return "m3x3";
+ case OPCODE_M3X2: return "m3x2";
+ case OPCODE_CALL: return "call";
+ case OPCODE_CALLNZ: return "callnz";
+ case OPCODE_LOOP: return "loop";
+ case OPCODE_RET: return "ret";
+ case OPCODE_ENDLOOP: return "endloop";
+ case OPCODE_LABEL: return "label";
+ case OPCODE_DCL: return "dcl";
+ case OPCODE_POW: return "pow";
+ case OPCODE_CRS: return "crs";
+ case OPCODE_SGN: return "sgn";
+ case OPCODE_ABS: return "abs";
+ case OPCODE_NRM: return "nrm";
+ case OPCODE_SINCOS: return "sincos";
+ case OPCODE_REP: return "rep";
+ case OPCODE_ENDREP: return "endrep";
+ case OPCODE_IF: return "if";
+ case OPCODE_IFC: return "ifc";
+ case OPCODE_ELSE: return "else";
+ case OPCODE_ENDIF: return "endif";
+ case OPCODE_BREAK: return "break";
+ case OPCODE_BREAKC: return "breakc";
+ case OPCODE_MOVA: return "mova";
+ case OPCODE_DEFB: return "defb";
+ case OPCODE_DEFI: return "defi";
+ case OPCODE_TEXCOORD: return "texcoord";
+ case OPCODE_TEXKILL: return "texkill";
+ case OPCODE_TEX:
+ if(version < 0x0104) return "tex";
+ else return "texld";
+ case OPCODE_TEXBEM: return "texbem";
+ case OPCODE_TEXBEML: return "texbeml";
+ case OPCODE_TEXREG2AR: return "texreg2ar";
+ case OPCODE_TEXREG2GB: return "texreg2gb";
+ case OPCODE_TEXM3X2PAD: return "texm3x2pad";
+ case OPCODE_TEXM3X2TEX: return "texm3x2tex";
+ case OPCODE_TEXM3X3PAD: return "texm3x3pad";
+ case OPCODE_TEXM3X3TEX: return "texm3x3tex";
+ case OPCODE_RESERVED0: return "reserved0";
+ case OPCODE_TEXM3X3SPEC: return "texm3x3spec";
+ case OPCODE_TEXM3X3VSPEC: return "texm3x3vspec";
+ case OPCODE_EXPP: return "expp";
+ case OPCODE_LOGP: return "logp";
+ case OPCODE_CND: return "cnd";
+ case OPCODE_DEF: return "def";
+ case OPCODE_TEXREG2RGB: return "texreg2rgb";
+ case OPCODE_TEXDP3TEX: return "texdp3tex";
+ case OPCODE_TEXM3X2DEPTH: return "texm3x2depth";
+ case OPCODE_TEXDP3: return "texdp3";
+ case OPCODE_TEXM3X3: return "texm3x3";
+ case OPCODE_TEXDEPTH: return "texdepth";
+ case OPCODE_CMP: return "cmp";
+ case OPCODE_BEM: return "bem";
+ case OPCODE_DP2ADD: return "dp2add";
+ case OPCODE_DSX: return "dsx";
+ case OPCODE_DSY: return "dsy";
+ case OPCODE_TEXLDD: return "texldd";
+ case OPCODE_SETP: return "setp";
+ case OPCODE_TEXLDL: return "texldl";
+ case OPCODE_BREAKP: return "breakp";
+ case OPCODE_PHASE: return "phase";
+ case OPCODE_COMMENT: return "comment";
+ case OPCODE_END: return "end";
+ case OPCODE_PS_1_0: return "ps_1_0";
+ case OPCODE_PS_1_1: return "ps_1_1";
+ case OPCODE_PS_1_2: return "ps_1_2";
+ case OPCODE_PS_1_3: return "ps_1_3";
+ case OPCODE_PS_1_4: return "ps_1_4";
+ case OPCODE_PS_2_0: return "ps_2_0";
+ case OPCODE_PS_2_x: return "ps_2_x";
+ case OPCODE_PS_3_0: return "ps_3_0";
+ case OPCODE_VS_1_0: return "vs_1_0";
+ case OPCODE_VS_1_1: return "vs_1_1";
+ case OPCODE_VS_2_0: return "vs_2_0";
+ case OPCODE_VS_2_x: return "vs_2_x";
+ case OPCODE_VS_2_sw: return "vs_2_sw";
+ case OPCODE_VS_3_0: return "vs_3_0";
+ case OPCODE_VS_3_sw: return "vs_3_sw";
+ default:
+ ASSERT(false);
+ }
+
+ return "<unknown>";
+ }
+
+ std::string Shader::Instruction::Operation::controlString() const
+ {
+ if(opcode != OPCODE_LOOP && opcode != OPCODE_BREAKC && opcode != OPCODE_IFC && opcode != OPCODE_SETP)
+ {
+ if(project) return "p";
+
+ if(bias) return "b";
+
+ // FIXME: LOD
+ }
+
+ switch(control)
+ {
+ case 1: return "_gt";
+ case 2: return "_eq";
+ case 3: return "_ge";
+ case 4: return "_lt";
+ case 5: return "_ne";
+ case 6: return "_le";
+ default:
+ return "";
+ // ASSERT(false); // FIXME
+ }
+ }
+
+ std::string Shader::Instruction::DestinationParameter::modifierString() const
+ {
+ if(type == PARAMETER_VOID || type == PARAMETER_LABEL)
+ {
+ return "";
+ }
+
+ std::string modifierString;
+
+ if(saturate)
+ {
+ modifierString += "_sat";
+ }
+
+ if(partialPrecision)
+ {
+ modifierString += "_pp";
+ }
+
+ if(centroid)
+ {
+ modifierString += "_centroid";
+ }
+
+ return modifierString;
+ }
+
+ std::string Shader::Instruction::DestinationParameter::shiftString() const
+ {
+ if(type == PARAMETER_VOID || type == PARAMETER_LABEL)
+ {
+ return "";
+ }
+
+ switch(shift)
+ {
+ case 0: return "";
+ case 1: return "_x2";
+ case 2: return "_x4";
+ case 3: return "_x8";
+ case -1: return "_d2";
+ case -2: return "_d4";
+ case -3: return "_d8";
+ default:
+ return "";
+ // ASSERT(false); // FIXME
+ }
+ }
+
+ std::string Shader::Instruction::DestinationParameter::maskString() const
+ {
+ if(type == PARAMETER_VOID || type == PARAMETER_LABEL)
+ {
+ return "";
+ }
+
+ switch(mask)
+ {
+ case 0x0: return "";
+ case 0x1: return ".x";
+ case 0x2: return ".y";
+ case 0x3: return ".xy";
+ case 0x4: return ".z";
+ case 0x5: return ".xz";
+ case 0x6: return ".yz";
+ case 0x7: return ".xyz";
+ case 0x8: return ".w";
+ case 0x9: return ".xw";
+ case 0xA: return ".yw";
+ case 0xB: return ".xyw";
+ case 0xC: return ".zw";
+ case 0xD: return ".xzw";
+ case 0xE: return ".yzw";
+ case 0xF: return "";
+ default:
+ ASSERT(false);
+ }
+
+ return "";
+ }
+
+ std::string Shader::Instruction::SourceParameter::preModifierString() const
+ {
+ if(type == PARAMETER_VOID)
+ {
+ return "";
+ }
+
+ switch(modifier)
+ {
+ case MODIFIER_NONE: return "";
+ case MODIFIER_NEGATE: return "-";
+ case MODIFIER_BIAS: return "";
+ case MODIFIER_BIAS_NEGATE: return "-";
+ case MODIFIER_SIGN: return "";
+ case MODIFIER_SIGN_NEGATE: return "-";
+ case MODIFIER_COMPLEMENT: return "1-";
+ case MODIFIER_X2: return "";
+ case MODIFIER_X2_NEGATE: return "-";
+ case MODIFIER_DZ: return "";
+ case MODIFIER_DW: return "";
+ case MODIFIER_ABS: return "";
+ case MODIFIER_ABS_NEGATE: return "-";
+ case MODIFIER_NOT: return "!";
+ default:
+ ASSERT(false);
+ }
+
+ return "";
+ }
+
+ std::string Shader::Instruction::Parameter::relativeString() const
+ {
+ if(!relative) return "";
+
+ if(relativeType == Parameter::PARAMETER_ADDR)
+ {
+ switch(relativeSwizzle & 0x03)
+ {
+ case 0: return "[a0.x]";
+ case 1: return "[a0.y]";
+ case 2: return "[a0.z]";
+ case 3: return "[a0.w]";
+ }
+ }
+ else if(relativeType == Parameter::PARAMETER_LOOP)
+ {
+ return "[aL]";
+ }
+ else ASSERT(false);
+
+ return "";
+ }
+
+ std::string Shader::Instruction::SourceParameter::postModifierString() const
+ {
+ if(type == PARAMETER_VOID)
+ {
+ return "";
+ }
+
+ switch(modifier)
+ {
+ case MODIFIER_NONE: return "";
+ case MODIFIER_NEGATE: return "";
+ case MODIFIER_BIAS: return "_bias";
+ case MODIFIER_BIAS_NEGATE: return "_bias";
+ case MODIFIER_SIGN: return "_bx2";
+ case MODIFIER_SIGN_NEGATE: return "_bx2";
+ case MODIFIER_COMPLEMENT: return "";
+ case MODIFIER_X2: return "_x2";
+ case MODIFIER_X2_NEGATE: return "_x2";
+ case MODIFIER_DZ: return "_dz";
+ case MODIFIER_DW: return "_dw";
+ case MODIFIER_ABS: return "_abs";
+ case MODIFIER_ABS_NEGATE: return "_abs";
+ case MODIFIER_NOT: return "";
+ default:
+ ASSERT(false);
+ }
+
+ return "";
+ }
+
+ std::string Shader::Instruction::SourceParameter::swizzleString() const
+ {
+ return Instruction::swizzleString(type, swizzle);
+ }
+
+ void Shader::Instruction::parseOperationToken(unsigned long token, unsigned char majorVersion)
+ {
+ if((token & 0xFFFF0000) == 0xFFFF0000 || (token & 0xFFFF0000) == 0xFFFE0000) // Version token
+ {
+ operation.opcode = (Operation::Opcode)token;
+ operation.predicate = false;
+ operation.coissue = false;
+ }
+ else
+ {
+ operation.opcode = (Operation::Opcode)(token & 0x0000FFFF);
+ operation.control = (Operation::Control)((token & 0x00FF0000) >> 16);
+
+ int size = (token & 0x0F000000) >> 24;
+
+ operation.predicate = (token & 0x10000000) != 0x00000000;
+ operation.coissue = (token & 0x40000000) != 0x00000000;
+
+ if(majorVersion < 2)
+ {
+ if(size != 0)
+ {
+ ASSERT(false); // Reserved
+ }
+ }
+
+ if(majorVersion < 2)
+ {
+ if(operation.predicate)
+ {
+ ASSERT(false);
+ }
+ }
+
+ if((token & 0x20000000) != 0x00000000)
+ {
+ ASSERT(false); // Reserved
+ }
+
+ if(majorVersion >= 2)
+ {
+ if(operation.coissue)
+ {
+ ASSERT(false); // Reserved
+ }
+ }
+
+ if((token & 0x80000000) != 0x00000000)
+ {
+ ASSERT(false);
+ }
+ }
+ }
+
+ void Shader::Instruction::parseDeclarationToken(unsigned long token)
+ {
+ operation.samplerType = (Operation::SamplerType)((token & 0x78000000) >> 27);
+ operation.usage = (Operation::Usage)(token & 0x0000001F);
+ operation.usageIndex = (unsigned char)((token & 0x000F0000) >> 16);
+ }
+
+ void Shader::Instruction::parseDestinationToken(const unsigned long *token, unsigned char majorVersion)
+ {
+ destinationParameter.index = (unsigned short)(token[0] & 0x000007FF);
+ destinationParameter.type = (Parameter::Type)(((token[0] & 0x00001800) >> 8) | ((token[0] & 0x70000000) >> 28));
+
+ // TODO: Check type and index range
+
+ destinationParameter.relative = (token[0] & 0x00002000) != 0x00000000;
+ destinationParameter.relativeType = Parameter::PARAMETER_ADDR;
+ destinationParameter.relativeSwizzle = 0x00;
+
+ if(destinationParameter.relative && majorVersion >= 3)
+ {
+ destinationParameter.relativeType = (Parameter::Type)(((token[1] & 0x00001800) >> 8) | ((token[1] & 0x70000000) >> 28));
+ destinationParameter.relativeSwizzle = (unsigned char)((token[1] & 0x00FF0000) >> 16);
+ }
+ else if(destinationParameter.relative) ASSERT(false); // Reserved
+
+ if((token[0] & 0x0000C000) != 0x00000000)
+ {
+ ASSERT(false); // Reserved
+ }
+
+ destinationParameter.mask = (unsigned char)((token[0] & 0x000F0000) >> 16);
+ destinationParameter.saturate = (token[0] & 0x00100000) != 0;
+ destinationParameter.partialPrecision = (token[0] & 0x00200000) != 0;
+ destinationParameter.centroid = (token[0] & 0x00400000) != 0;
+ destinationParameter.shift = (signed char)((token[0] & 0x0F000000) >> 20) >> 4;
+
+ if(majorVersion >= 2)
+ {
+ if(destinationParameter.shift)
+ {
+ ASSERT(false); // Reserved
+ }
+ }
+
+ if((token[0] & 0x80000000) != 0x80000000)
+ {
+ ASSERT(false);
+ }
+ }
+
+ void Shader::Instruction::parseSourceToken(int i, const unsigned long *token, unsigned char majorVersion)
+ {
+ // Defaults
+ sourceParameter[i].value = (float&)*token;
+ sourceParameter[i].type = Parameter::PARAMETER_VOID;
+ sourceParameter[i].modifier = SourceParameter::MODIFIER_NONE;
+ sourceParameter[i].swizzle = 0xE4;
+ sourceParameter[i].relative = false;
+ sourceParameter[i].relativeType = Parameter::PARAMETER_ADDR;
+ sourceParameter[i].relativeSwizzle = 0x00;
+
+ switch(operation.opcode)
+ {
+ case Instruction::Operation::OPCODE_DEF:
+ sourceParameter[i].type = Parameter::PARAMETER_FLOATLITERAL;
+ break;
+ case Instruction::Operation::OPCODE_DEFB:
+ sourceParameter[i].type = Parameter::PARAMETER_BOOLLITERAL;
+ break;
+ case Instruction::Operation::OPCODE_DEFI:
+ sourceParameter[i].type = Parameter::PARAMETER_INTLITERAL;
+ break;
+ default:
+ sourceParameter[i].index = (unsigned short)(token[0] & 0x000007FF);
+ sourceParameter[i].type = (Parameter::Type)(((token[0] & 0x00001800) >> 8) | ((token[0] & 0x70000000) >> 28));
+
+ // FIXME: Check type and index range
+
+ sourceParameter[i].relative = (token[0] & 0x00002000) != 0x00000000;
+
+ if((token[0] & 0x0000C000) != 0x00000000)
+ {
+ if(operation.opcode != Operation::OPCODE_DEF &&
+ operation.opcode != Operation::OPCODE_DEFI &&
+ operation.opcode != Operation::OPCODE_DEFB)
+ {
+ ASSERT(false);
+ }
+ }
+
+ sourceParameter[i].swizzle = (unsigned char)((token[0] & 0x00FF0000) >> 16);
+ sourceParameter[i].modifier = (SourceParameter::Modifier)((token[0] & 0x0F000000) >> 24);
+
+ if((token[0] & 0x80000000) != 0x80000000)
+ {
+ if(operation.opcode != Operation::OPCODE_DEF &&
+ operation.opcode != Operation::OPCODE_DEFI &&
+ operation.opcode != Operation::OPCODE_DEFB)
+ {
+ ASSERT(false);
+ }
+ }
+
+ if(sourceParameter[i].relative && majorVersion >= 2)
+ {
+ sourceParameter[i].relativeType = (Parameter::Type)(((token[1] & 0x00001800) >> 8) | ((token[1] & 0x70000000) >> 28));
+ sourceParameter[i].relativeSwizzle = (unsigned char)((token[1] & 0x00FF0000) >> 16);
+ }
+ }
+ }
+
+ std::string Shader::Instruction::swizzleString(Parameter::Type type, unsigned char swizzle)
+ {
+ if(type == Parameter::PARAMETER_VOID || type == Parameter::PARAMETER_LABEL || swizzle == 0xE4)
+ {
+ return "";
+ }
+
+ int x = (swizzle & 0x03) >> 0;
+ int y = (swizzle & 0x0C) >> 2;
+ int z = (swizzle & 0x30) >> 4;
+ int w = (swizzle & 0xC0) >> 6;
+
+ std::string swizzleString = ".";
+
+ switch(x)
+ {
+ case 0: swizzleString += "x"; break;
+ case 1: swizzleString += "y"; break;
+ case 2: swizzleString += "z"; break;
+ case 3: swizzleString += "w"; break;
+ }
+
+ if(!(x == y && y == z && z == w))
+ {
+ switch(y)
+ {
+ case 0: swizzleString += "x"; break;
+ case 1: swizzleString += "y"; break;
+ case 2: swizzleString += "z"; break;
+ case 3: swizzleString += "w"; break;
+ }
+
+ if(!(y == z && z == w))
+ {
+ switch(z)
+ {
+ case 0: swizzleString += "x"; break;
+ case 1: swizzleString += "y"; break;
+ case 2: swizzleString += "z"; break;
+ case 3: swizzleString += "w"; break;
+ }
+
+ if(!(z == w))
+ {
+ switch(w)
+ {
+ case 0: swizzleString += "x"; break;
+ case 1: swizzleString += "y"; break;
+ case 2: swizzleString += "z"; break;
+ case 3: swizzleString += "w"; break;
+ }
+ }
+ }
+ }
+
+ return swizzleString;
+ }
+
+ std::string Shader::Instruction::Parameter::string(ShaderType shaderType, unsigned short version) const
+ {
+ std::ostringstream buffer;
+
+ if(type == PARAMETER_FLOATLITERAL)
+ {
+ buffer << value;
+
+ return buffer.str();
+ }
+ else
+ {
+ if(type != PARAMETER_RASTOUT && !(type == PARAMETER_ADDR && shaderType == SHADER_VERTEX) && type != PARAMETER_LOOP && type != PARAMETER_PREDICATE && type != PARAMETER_MISCTYPE)
+ {
+ buffer << index;
+
+ return typeString(shaderType, version) + buffer.str();
+ }
+ else
+ {
+ return typeString(shaderType, version);
+ }
+ }
+ }
+
+ std::string Shader::Instruction::Parameter::typeString(ShaderType shaderType, unsigned short version) const
+ {
+ switch(type)
+ {
+ case PARAMETER_TEMP: return "r";
+ case PARAMETER_INPUT: return "v";
+ case PARAMETER_CONST: return "c";
+ case PARAMETER_TEXTURE:
+ // case PARAMETER_ADDR:
+ if(shaderType == SHADER_PIXEL) return "t";
+ else return "a0";
+ case PARAMETER_RASTOUT:
+ if(index == 0) return "oPos";
+ else if(index == 1) return "oFog";
+ else if(index == 2) return "oPts";
+ else ASSERT(false);
+ case PARAMETER_ATTROUT: return "oD";
+ case PARAMETER_TEXCRDOUT:
+ // case PARAMETER_OUTPUT: return "";
+ if(version < 0x0300) return "oT";
+ else return "o";
+ case PARAMETER_CONSTINT: return "i";
+ case PARAMETER_COLOROUT: return "oC";
+ case PARAMETER_DEPTHOUT: return "oDepth";
+ case PARAMETER_SAMPLER: return "s";
+ // case PARAMETER_CONST2: return "";
+ // case PARAMETER_CONST3: return "";
+ // case PARAMETER_CONST4: return "";
+ case PARAMETER_CONSTBOOL: return "b";
+ case PARAMETER_LOOP: return "aL";
+ // case PARAMETER_TEMPFLOAT16: return "";
+ case PARAMETER_MISCTYPE:
+ if(index == 0) return "vPos";
+ else if(index == 1) return "vFace";
+ else ASSERT(false);
+ case PARAMETER_LABEL: return "l";
+ case PARAMETER_PREDICATE: return "p0";
+ case PARAMETER_FLOATLITERAL: return "";
+ case PARAMETER_BOOLLITERAL: return "";
+ case PARAMETER_INTLITERAL: return "";
+ // case PARAMETER_VOID: return "";
+ default:
+ ASSERT(false);
+ }
+
+ return "";
+ }
+
+ Shader::Shader(const unsigned long *shaderToken)
+ {
+ instruction = 0;
+ length = 0;
+
+ tokenCount = 0;
+
+ while(shaderToken[tokenCount] != 0x0000FFFF)
+ {
+ tokenCount += sw::Shader::size(shaderToken[tokenCount], (unsigned short)(shaderToken[0] & 0xFFFF)) + 1;
+ }
+
+ tokenCount += 1;
+
+ this->shaderToken = new unsigned long[tokenCount];
+ memcpy(this->shaderToken, shaderToken, tokenCount * sizeof(unsigned long));
+
+ unsigned long *hashTokens = new unsigned long[tokenCount];
+ memcpy(hashTokens, shaderToken, tokenCount * sizeof(unsigned long));
+ removeComments(hashTokens, tokenCount);
+ hash = FNV_1((unsigned char*)hashTokens, tokenCount * sizeof(unsigned long));
+ delete[] hashTokens;
+ }
+
+ Shader::~Shader()
+ {
+ delete[] shaderToken;
+ shaderToken = 0;
+
+ for(int i = 0; i < length; i++)
+ {
+ delete instruction[i];
+ instruction[i] = 0;
+ }
+
+ delete[] instruction;
+ instruction = 0;
+ }
+
+ void Shader::getFunction(void *data, unsigned int *size)
+ {
+ if(data)
+ {
+ memcpy(data, shaderToken, tokenCount * 4);
+ }
+
+ *size = tokenCount * 4;
+ }
+
+ int Shader::size(unsigned long opcode) const
+ {
+ return size(opcode, version);
+ }
+
+ int Shader::size(unsigned long opcode, unsigned short version)
+ {
+ if(version > 0x0300)
+ {
+ ASSERT(false);
+ }
+
+ static const char size[] =
+ {
+ 0, // NOP = 0
+ 2, // MOV
+ 3, // ADD
+ 3, // SUB
+ 4, // MAD
+ 3, // MUL
+ 2, // RCP
+ 2, // RSQ
+ 3, // DP3
+ 3, // DP4
+ 3, // MIN
+ 3, // MAX
+ 3, // SLT
+ 3, // SGE
+ 2, // EXP
+ 2, // LOG
+ 2, // LIT
+ 3, // DST
+ 4, // LRP
+ 2, // FRC
+ 3, // M4x4
+ 3, // M4x3
+ 3, // M3x4
+ 3, // M3x3
+ 3, // M3x2
+ 1, // CALL
+ 2, // CALLNZ
+ 2, // LOOP
+ 0, // RET
+ 0, // ENDLOOP
+ 1, // LABEL
+ 2, // DCL
+ 3, // POW
+ 3, // CRS
+ 4, // SGN
+ 2, // ABS
+ 2, // NRM
+ 4, // SINCOS
+ 1, // REP
+ 0, // ENDREP
+ 1, // IF
+ 2, // IFC
+ 0, // ELSE
+ 0, // ENDIF
+ 0, // BREAK
+ 2, // BREAKC
+ 2, // MOVA
+ 2, // DEFB
+ 5, // DEFI
+ -1, // 49
+ -1, // 50
+ -1, // 51
+ -1, // 52
+ -1, // 53
+ -1, // 54
+ -1, // 55
+ -1, // 56
+ -1, // 57
+ -1, // 58
+ -1, // 59
+ -1, // 60
+ -1, // 61
+ -1, // 62
+ -1, // 63
+ 1, // TEXCOORD = 64
+ 1, // TEXKILL
+ 1, // TEX
+ 2, // TEXBEM
+ 2, // TEXBEML
+ 2, // TEXREG2AR
+ 2, // TEXREG2GB
+ 2, // TEXM3x2PAD
+ 2, // TEXM3x2TEX
+ 2, // TEXM3x3PAD
+ 2, // TEXM3x3TEX
+ -1, // RESERVED0
+ 3, // TEXM3x3SPEC
+ 2, // TEXM3x3VSPEC
+ 2, // EXPP
+ 2, // LOGP
+ 4, // CND
+ 5, // DEF
+ 2, // TEXREG2RGB
+ 2, // TEXDP3TEX
+ 2, // TEXM3x2DEPTH
+ 2, // TEXDP3
+ 2, // TEXM3x3
+ 1, // TEXDEPTH
+ 4, // CMP
+ 3, // BEM
+ 4, // DP2ADD
+ 2, // DSX
+ 2, // DSY
+ 5, // TEXLDD
+ 3, // SETP
+ 3, // TEXLDL
+ 2, // BREAKP
+ -1, // 97
+ -1, // 98
+ -1, // 99
+ -1, // 100
+ -1, // 101
+ -1, // 102
+ -1, // 103
+ -1, // 104
+ -1, // 105
+ -1, // 106
+ -1, // 107
+ -1, // 108
+ -1, // 109
+ -1, // 110
+ -1, // 111
+ -1, // 112
+ };
+
+ int length = 0;
+
+ if((opcode & 0x0000FFFF) == ShaderOperation::OPCODE_COMMENT)
+ {
+ return (opcode & 0x7FFF0000) >> 16;
+ }
+
+ if(opcode != ShaderOperation::OPCODE_PS_1_0 &&
+ opcode != ShaderOperation::OPCODE_PS_1_1 &&
+ opcode != ShaderOperation::OPCODE_PS_1_2 &&
+ opcode != ShaderOperation::OPCODE_PS_1_3 &&
+ opcode != ShaderOperation::OPCODE_PS_1_4 &&
+ opcode != ShaderOperation::OPCODE_PS_2_0 &&
+ opcode != ShaderOperation::OPCODE_PS_2_x &&
+ opcode != ShaderOperation::OPCODE_PS_3_0 &&
+ opcode != ShaderOperation::OPCODE_VS_1_0 &&
+ opcode != ShaderOperation::OPCODE_VS_1_1 &&
+ opcode != ShaderOperation::OPCODE_VS_2_0 &&
+ opcode != ShaderOperation::OPCODE_VS_2_x &&
+ opcode != ShaderOperation::OPCODE_VS_2_sw &&
+ opcode != ShaderOperation::OPCODE_VS_3_0 &&
+ opcode != ShaderOperation::OPCODE_VS_3_sw &&
+ opcode != ShaderOperation::OPCODE_PHASE &&
+ opcode != ShaderOperation::OPCODE_END)
+ {
+ if(version >= 0x0200)
+ {
+ length = (opcode & 0x0F000000) >> 24;
+ }
+ else
+ {
+ length = size[opcode & 0x0000FFFF];
+ }
+ }
+
+ if(length < 0)
+ {
+ ASSERT(false);
+ }
+
+ if(version == 0x0104)
+ {
+ switch(opcode & 0x0000FFFF)
+ {
+ case ShaderOperation::OPCODE_TEX:
+ length += 1;
+ break;
+ case ShaderOperation::OPCODE_TEXCOORD:
+ length += 1;
+ break;
+ default:
+ break;
+ }
+ }
+
+ return length;
+ }
+
+ bool Shader::maskContainsComponent(int mask, int component)
+ {
+ return (mask & (1 << component)) != 0;
+ }
+
+ bool Shader::swizzleContainsComponent(int swizzle, int component)
+ {
+ if((swizzle & 0x03) >> 0 == component) return true;
+ if((swizzle & 0x0C) >> 2 == component) return true;
+ if((swizzle & 0x30) >> 4 == component) return true;
+ if((swizzle & 0xC0) >> 6 == component) return true;
+
+ return false;
+ }
+
+ bool Shader::swizzleContainsComponentMasked(int swizzle, int component, int mask)
+ {
+ if(mask & 0x1) if((swizzle & 0x03) >> 0 == component) return true;
+ if(mask & 0x2) if((swizzle & 0x0C) >> 2 == component) return true;
+ if(mask & 0x4) if((swizzle & 0x30) >> 4 == component) return true;
+ if(mask & 0x8) if((swizzle & 0xC0) >> 6 == component) return true;
+
+ return false;
+ }
+
+ bool Shader::containsDynamicBranching() const
+ {
+ return dynamicBranching;
+ }
+
+ bool Shader::usesSampler(int index) const
+ {
+ return (sampler & (1 << index)) != 0;
+ }
+
+ int64_t Shader::getHash() const
+ {
+ return hash;
+ }
+
+ int Shader::getLength() const
+ {
+ return length;
+ }
+
+ Shader::ShaderType Shader::getShaderType() const
+ {
+ return shaderType;
+ }
+
+ unsigned short Shader::getVersion() const
+ {
+ return version;
+ }
+
+ void Shader::print(const char *fileName, ...) const
+ {
+ char fullName[1024 + 1];
+
+ va_list vararg;
+ va_start(vararg, fileName);
+ vsnprintf(fullName, 1024, fileName, vararg);
+ va_end(vararg);
+
+ std::ofstream file(fullName, std::ofstream::out | std::ofstream::app);
+
+ for(int i = 0; i < length; i++)
+ {
+ file << instruction[i]->string(shaderType, version) << std::endl;
+ }
+ }
+
+ void Shader::printInstruction(int index, const char *fileName) const
+ {
+ std::ofstream file(fileName, std::ofstream::out | std::ofstream::app);
+
+ file << instruction[index]->string(shaderType, version) << std::endl;
+ }
+
+ const ShaderInstruction *Shader::getInstruction(int i) const
+ {
+ if(i < 0 || i >= length)
+ {
+ ASSERT(false);
+ }
+
+ return instruction[i];
+ }
+
+ void Shader::analyzeDirtyConstants()
+ {
+ dirtyConstantsF = 0;
+ dirtyConstantsI = 0;
+ dirtyConstantsB = 0;
+
+ for(int i = 0; i < length; i++)
+ {
+ switch(instruction[i]->operation.opcode)
+ {
+ case ShaderOperation::OPCODE_DEF:
+ if(instruction[i]->destinationParameter.index + 1 > dirtyConstantsF)
+ {
+ dirtyConstantsF = instruction[i]->destinationParameter.index + 1;
+ }
+ break;
+ case ShaderOperation::OPCODE_DEFI:
+ if(instruction[i]->destinationParameter.index + 1 > dirtyConstantsI)
+ {
+ dirtyConstantsI = instruction[i]->destinationParameter.index + 1;
+ }
+ break;
+ case ShaderOperation::OPCODE_DEFB:
+ if(instruction[i]->destinationParameter.index + 1 > dirtyConstantsB)
+ {
+ dirtyConstantsB = instruction[i]->destinationParameter.index + 1;
+ }
+ break;
+ }
+ }
+ }
+
+ void Shader::analyzeDynamicBranching()
+ {
+ dynamicBranching = false;
+
+ for(int i = 0; i < length; i++)
+ {
+ switch(instruction[i]->getOpcode())
+ {
+ case ShaderOperation::OPCODE_CALLNZ:
+ case ShaderOperation::OPCODE_IF:
+ case ShaderOperation::OPCODE_IFC:
+ case ShaderOperation::OPCODE_BREAK:
+ case ShaderOperation::OPCODE_BREAKC:
+ case ShaderOperation::OPCODE_SETP:
+ case ShaderOperation::OPCODE_BREAKP:
+ if(instruction[i]->sourceParameter[0].type != ShaderParameter::PARAMETER_CONSTBOOL)
+ {
+ dynamicBranching = true;
+ break;
+ }
+ }
+ }
+ }
+
+ void Shader::analyzeSamplers()
+ {
+ sampler = 0;
+
+ for(int i = 0; i < length; i++)
+ {
+ switch(instruction[i]->getOpcode())
+ {
+ case ShaderOperation::OPCODE_TEX:
+ case ShaderOperation::OPCODE_TEXBEM:
+ case ShaderOperation::OPCODE_TEXBEML:
+ case ShaderOperation::OPCODE_TEXREG2AR:
+ case ShaderOperation::OPCODE_TEXREG2GB:
+ case ShaderOperation::OPCODE_TEXM3X2TEX:
+ case ShaderOperation::OPCODE_TEXM3X3TEX:
+ case ShaderOperation::OPCODE_TEXM3X3SPEC:
+ case ShaderOperation::OPCODE_TEXM3X3VSPEC:
+ case ShaderOperation::OPCODE_TEXREG2RGB:
+ case ShaderOperation::OPCODE_TEXDP3TEX:
+ case ShaderOperation::OPCODE_TEXM3X2DEPTH:
+ case ShaderOperation::OPCODE_TEXLDD:
+ case ShaderOperation::OPCODE_TEXLDL:
+ {
+ ShaderParameter &dst = instruction[i]->destinationParameter;
+ ShaderParameter &src1 = instruction[i]->sourceParameter[1];
+
+ if(majorVersion >= 2)
+ {
+ ASSERT(src1.type == ShaderParameter::PARAMETER_SAMPLER);
+ sampler |= 1 << src1.index;
+ }
+ else
+ {
+ sampler |= 1 << dst.index;
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ void Shader::removeComments(unsigned long *shaderToken, int tokenCount)
+ {
+ for(int i = 0; i < tokenCount; )
+ {
+ int instructionSize = sw::Shader::size(shaderToken[i], (unsigned short)(shaderToken[0] & 0xFFFF)) + 1;
+
+ if((shaderToken[i] & 0x0000FFFF) == ShaderOperation::OPCODE_COMMENT)
+ {
+ for(int j = 0; j < instructionSize; j++)
+ {
+ shaderToken[i + j] = ShaderOperation::OPCODE_NOP;
+ }
+ }
+
+ i += instructionSize;
+ }
+ }
+}
diff --git a/src/Shader/Shader.hpp b/src/Shader/Shader.hpp
new file mode 100644
index 0000000..d2d6fe3
--- /dev/null
+++ b/src/Shader/Shader.hpp
@@ -0,0 +1,459 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_Shader_hpp
+#define sw_Shader_hpp
+
+#include "Common/Types.hpp"
+
+#include <string>
+
+namespace sw
+{
+ class Shader
+ {
+ public:
+ enum ShaderType
+ {
+ SHADER_PIXEL = 0xFFFF,
+ SHADER_VERTEX = 0xFFFE,
+ SHADER_GEOMETRY = 0xFFFD
+ };
+
+ class Instruction
+ {
+ friend Shader;
+
+ public:
+ Instruction();
+ Instruction(const unsigned long *token, int size, unsigned char majorVersion);
+
+ virtual ~Instruction();
+
+ struct Operation
+ {
+ enum Opcode
+ {
+ // Extracted from d3d9types.h
+ OPCODE_NOP = 0,
+ OPCODE_MOV,
+ OPCODE_ADD,
+ OPCODE_SUB,
+ OPCODE_MAD,
+ OPCODE_MUL,
+ OPCODE_RCP,
+ OPCODE_RSQ,
+ OPCODE_DP3,
+ OPCODE_DP4,
+ OPCODE_MIN,
+ OPCODE_MAX,
+ OPCODE_SLT,
+ OPCODE_SGE,
+ OPCODE_EXP,
+ OPCODE_LOG,
+ OPCODE_LIT,
+ OPCODE_DST,
+ OPCODE_LRP,
+ OPCODE_FRC,
+ OPCODE_M4X4,
+ OPCODE_M4X3,
+ OPCODE_M3X4,
+ OPCODE_M3X3,
+ OPCODE_M3X2,
+ OPCODE_CALL,
+ OPCODE_CALLNZ,
+ OPCODE_LOOP,
+ OPCODE_RET,
+ OPCODE_ENDLOOP,
+ OPCODE_LABEL,
+ OPCODE_DCL,
+ OPCODE_POW,
+ OPCODE_CRS,
+ OPCODE_SGN,
+ OPCODE_ABS,
+ OPCODE_NRM,
+ OPCODE_SINCOS,
+ OPCODE_REP,
+ OPCODE_ENDREP,
+ OPCODE_IF,
+ OPCODE_IFC,
+ OPCODE_ELSE,
+ OPCODE_ENDIF,
+ OPCODE_BREAK,
+ OPCODE_BREAKC,
+ OPCODE_MOVA,
+ OPCODE_DEFB,
+ OPCODE_DEFI,
+
+ OPCODE_TEXCOORD = 64,
+ OPCODE_TEXKILL,
+ OPCODE_TEX,
+ OPCODE_TEXBEM,
+ OPCODE_TEXBEML,
+ OPCODE_TEXREG2AR,
+ OPCODE_TEXREG2GB,
+ OPCODE_TEXM3X2PAD,
+ OPCODE_TEXM3X2TEX,
+ OPCODE_TEXM3X3PAD,
+ OPCODE_TEXM3X3TEX,
+ OPCODE_RESERVED0,
+ OPCODE_TEXM3X3SPEC,
+ OPCODE_TEXM3X3VSPEC,
+ OPCODE_EXPP,
+ OPCODE_LOGP,
+ OPCODE_CND,
+ OPCODE_DEF,
+ OPCODE_TEXREG2RGB,
+ OPCODE_TEXDP3TEX,
+ OPCODE_TEXM3X2DEPTH,
+ OPCODE_TEXDP3,
+ OPCODE_TEXM3X3,
+ OPCODE_TEXDEPTH,
+ OPCODE_CMP,
+ OPCODE_BEM,
+ OPCODE_DP2ADD,
+ OPCODE_DSX,
+ OPCODE_DSY,
+ OPCODE_TEXLDD,
+ OPCODE_SETP,
+ OPCODE_TEXLDL,
+ OPCODE_BREAKP,
+
+ OPCODE_PHASE = 0xFFFD,
+ OPCODE_COMMENT = 0xFFFE,
+ OPCODE_END = 0xFFFF,
+
+ OPCODE_PS_1_0 = 0xFFFF0100,
+ OPCODE_PS_1_1 = 0xFFFF0101,
+ OPCODE_PS_1_2 = 0xFFFF0102,
+ OPCODE_PS_1_3 = 0xFFFF0103,
+ OPCODE_PS_1_4 = 0xFFFF0104,
+ OPCODE_PS_2_0 = 0xFFFF0200,
+ OPCODE_PS_2_x = 0xFFFF0201,
+ OPCODE_PS_3_0 = 0xFFFF0300,
+
+ OPCODE_VS_1_0 = 0xFFFE0100,
+ OPCODE_VS_1_1 = 0xFFFE0101,
+ OPCODE_VS_2_0 = 0xFFFE0200,
+ OPCODE_VS_2_x = 0xFFFE0201,
+ OPCODE_VS_2_sw = 0xFFFE02FF,
+ OPCODE_VS_3_0 = 0xFFFE0300,
+ OPCODE_VS_3_sw = 0xFFFE03FF,
+ };
+
+ enum Control
+ {
+ CONTROL_RESERVED0,
+ CONTROL_GT,
+ CONTROL_EQ,
+ CONTROL_GE,
+ CONTROL_LT,
+ CONTROL_NE,
+ CONTROL_LE,
+ CONTROL_RESERVED1
+ };
+
+ enum SamplerType
+ {
+ SAMPLER_UNKNOWN,
+ SAMPLER_1D,
+ SAMPLER_2D,
+ SAMPLER_CUBE,
+ SAMPLER_VOLUME
+ };
+
+ enum Usage // For vertex input/output declarations
+ {
+ USAGE_POSITION = 0,
+ USAGE_BLENDWEIGHT = 1,
+ USAGE_BLENDINDICES = 2,
+ USAGE_NORMAL = 3,
+ USAGE_PSIZE = 4,
+ USAGE_TEXCOORD = 5,
+ USAGE_TANGENT = 6,
+ USAGE_BINORMAL = 7,
+ USAGE_TESSFACTOR = 8,
+ USAGE_POSITIONT = 9,
+ USAGE_COLOR = 10,
+ USAGE_FOG = 11,
+ USAGE_DEPTH = 12,
+ USAGE_SAMPLE = 13
+ };
+
+ Operation() : opcode(OPCODE_NOP), control(CONTROL_RESERVED0), predicate(false), predicateNot(false), predicateSwizzle(0xE4), coissue(false), samplerType(SAMPLER_UNKNOWN), usage(USAGE_POSITION), usageIndex(0)
+ {
+ }
+
+ std::string string(unsigned short version) const;
+ std::string controlString() const;
+
+ Opcode opcode;
+
+ union
+ {
+ Control control;
+
+ struct
+ {
+ unsigned char project : 1;
+ unsigned char bias : 1;
+ };
+ };
+
+ bool predicate;
+ bool predicateNot; // Negative predicate
+ unsigned char predicateSwizzle;
+
+ bool coissue;
+ SamplerType samplerType;
+ Usage usage;
+ unsigned char usageIndex;
+ };
+
+ struct Parameter
+ {
+ enum Type
+ {
+ PARAMETER_TEMP = 0,
+ PARAMETER_INPUT = 1,
+ PARAMETER_CONST = 2,
+ PARAMETER_TEXTURE = 3,
+ PARAMETER_ADDR = 3,
+ PARAMETER_RASTOUT = 4,
+ PARAMETER_ATTROUT = 5,
+ PARAMETER_TEXCRDOUT = 6,
+ PARAMETER_OUTPUT = 6,
+ PARAMETER_CONSTINT = 7,
+ PARAMETER_COLOROUT = 8,
+ PARAMETER_DEPTHOUT = 9,
+ PARAMETER_SAMPLER = 10,
+ PARAMETER_CONST2 = 11,
+ PARAMETER_CONST3 = 12,
+ PARAMETER_CONST4 = 13,
+ PARAMETER_CONSTBOOL = 14,
+ PARAMETER_LOOP = 15,
+ PARAMETER_TEMPFLOAT16 = 16,
+ PARAMETER_MISCTYPE = 17,
+ PARAMETER_LABEL = 18,
+ PARAMETER_PREDICATE = 19,
+
+ // Internally used
+ PARAMETER_FLOATLITERAL = 20,
+ PARAMETER_BOOLLITERAL = 21,
+ PARAMETER_INTLITERAL = 22,
+
+ PARAMETER_VOID
+ };
+
+ union
+ {
+ unsigned int index; // For registers
+ float value; // For float constants
+ int integer; // For integer constants
+ bool boolean; // For boolean constants
+ };
+
+ Parameter() : type(PARAMETER_VOID), index(0), relative(false), relativeType(PARAMETER_VOID), relativeSwizzle(0xE4)
+ {
+ }
+
+ std::string string(ShaderType shaderType, unsigned short version) const;
+ std::string typeString(ShaderType shaderType, unsigned short version) const;
+ std::string relativeString() const;
+
+ Type type;
+ bool relative;
+ Type relativeType;
+ unsigned char relativeSwizzle;
+ };
+
+ struct DestinationParameter : Parameter
+ {
+ union
+ {
+ unsigned char mask;
+
+ struct
+ {
+ bool x : 1;
+ bool y : 1;
+ bool z : 1;
+ bool w : 1;
+ };
+ };
+
+ DestinationParameter() : mask(0xF), saturate(false), partialPrecision(false), centroid(false), shift(0)
+ {
+ }
+
+ std::string modifierString() const;
+ std::string shiftString() const;
+ std::string maskString() const;
+
+ bool saturate;
+ bool partialPrecision;
+ bool centroid;
+ signed char shift;
+ };
+
+ struct SourceParameter : Parameter
+ {
+ enum Modifier
+ {
+ MODIFIER_NONE,
+ MODIFIER_NEGATE,
+ MODIFIER_BIAS,
+ MODIFIER_BIAS_NEGATE,
+ MODIFIER_SIGN,
+ MODIFIER_SIGN_NEGATE,
+ MODIFIER_COMPLEMENT,
+ MODIFIER_X2,
+ MODIFIER_X2_NEGATE,
+ MODIFIER_DZ,
+ MODIFIER_DW,
+ MODIFIER_ABS,
+ MODIFIER_ABS_NEGATE,
+ MODIFIER_NOT
+ };
+
+ SourceParameter() : swizzle(0xE4), modifier(MODIFIER_NONE)
+ {
+ }
+
+ std::string swizzleString() const;
+ std::string preModifierString() const;
+ std::string postModifierString() const;
+
+ unsigned char swizzle;
+ Modifier modifier;
+ };
+
+ void parseOperationToken(unsigned long token, unsigned char majorVersion);
+ void parseDeclarationToken(unsigned long token);
+ void parseDestinationToken(const unsigned long *token, unsigned char majorVersion);
+ void parseSourceToken(int i, const unsigned long *token, unsigned char majorVersion);
+
+ Operation::Opcode getOpcode() const;
+ const DestinationParameter &getDestinationParameter() const;
+ const SourceParameter &getSourceParameter(int i) const;
+
+ bool isCoissue() const;
+ bool isProject() const;
+ bool isBias() const;
+ bool isPredicate() const;
+ bool isPredicateNot() const;
+ unsigned char getPredicateSwizzle() const;
+ Operation::Control getControl() const;
+ Operation::Usage getUsage() const;
+ unsigned char getUsageIndex() const;
+ Operation::SamplerType getSamplerType() const;
+
+ std::string string(ShaderType shaderType, unsigned short version) const;
+
+ protected:
+ Operation operation;
+ DestinationParameter destinationParameter;
+ SourceParameter sourceParameter[4];
+
+ private:
+ static std::string swizzleString(Parameter::Type type, unsigned char swizzle);
+ };
+
+ Shader(const unsigned long *shaderToken);
+
+ ~Shader();
+
+ void getFunction(void *data, unsigned int *size);
+
+ int64_t getHash() const;
+ int getLength() const;
+ ShaderType getShaderType() const;
+ unsigned short getVersion() const;
+
+ const Instruction *getInstruction(int i) const;
+ int size(unsigned long opcode) const;
+ static int size(unsigned long opcode, unsigned short version);
+
+ void print(const char *fileName, ...) const;
+ void printInstruction(int index, const char *fileName) const;
+
+ static bool maskContainsComponent(int mask, int component);
+ static bool swizzleContainsComponent(int swizzle, int component);
+ static bool swizzleContainsComponentMasked(int swizzle, int component, int mask);
+
+ bool containsDynamicBranching() const;
+ bool usesSampler(int i) const;
+
+ struct Semantic
+ {
+ Semantic(unsigned char usage = 0xFF, unsigned char index = 0xFF) : usage(usage), index(index), centroid(false)
+ {
+ }
+
+ bool operator==(const Semantic &semantic) const
+ {
+ return usage == semantic.usage && index == semantic.index;
+ }
+
+ bool active() const
+ {
+ return usage != 0xFF;
+ }
+
+ unsigned char usage;
+ unsigned char index;
+ bool centroid;
+ };
+
+ unsigned int dirtyConstantsF; // FIXME: Private
+ unsigned int dirtyConstantsI; // FIXME: Private
+ unsigned int dirtyConstantsB; // FIXME: Private
+
+ protected:
+ void analyzeDirtyConstants();
+ void analyzeDynamicBranching();
+ void analyzeSamplers();
+
+ ShaderType shaderType;
+
+ union
+ {
+ unsigned short version;
+
+ struct
+ {
+ unsigned char minorVersion;
+ unsigned char majorVersion;
+ };
+ };
+
+ int length;
+ Instruction **instruction;
+
+ private:
+ static void removeComments(unsigned long *shaderToken, int tokenCount);
+
+ int64_t hash;
+
+ bool dynamicBranching;
+ unsigned short sampler;
+
+ unsigned long *shaderToken;
+ int tokenCount;
+ };
+
+ typedef Shader::Instruction::Operation ShaderOperation;
+ typedef Shader::Instruction ShaderInstruction;
+ typedef Shader::Instruction::Parameter ShaderParameter;
+ typedef Shader::Instruction::Operation::Opcode ShaderOpcode;
+}
+
+#endif // sw_Shader_hpp
diff --git a/src/Shader/ShaderCore.cpp b/src/Shader/ShaderCore.cpp
new file mode 100644
index 0000000..26facac
--- /dev/null
+++ b/src/Shader/ShaderCore.cpp
@@ -0,0 +1,396 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "ShaderCore.hpp"
+
+#include "Debug.hpp"
+
+namespace sw
+{
+ void ShaderCore::mov(Color4f &dst, Color4f &src, bool floorToInteger)
+ {
+ if(floorToInteger)
+ {
+ dst.x = Floor(src.x);
+ }
+ else
+ {
+ dst = src;
+ }
+ }
+
+ void ShaderCore::add(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ dst.x = src0.x + src1.x;
+ dst.y = src0.y + src1.y;
+ dst.z = src0.z + src1.z;
+ dst.w = src0.w + src1.w;
+ }
+
+ void ShaderCore::sub(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ dst.x = src0.x - src1.x;
+ dst.y = src0.y - src1.y;
+ dst.z = src0.z - src1.z;
+ dst.w = src0.w - src1.w;
+ }
+
+ void ShaderCore::mad(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2)
+ {
+ dst.x = src0.x * src1.x + src2.x;
+ dst.y = src0.y * src1.y + src2.y;
+ dst.z = src0.z * src1.z + src2.z;
+ dst.w = src0.w * src1.w + src2.w;
+ }
+
+ void ShaderCore::mul(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ dst.x = src0.x * src1.x;
+ dst.y = src0.y * src1.y;
+ dst.z = src0.z * src1.z;
+ dst.w = src0.w * src1.w;
+ }
+
+ void ShaderCore::rcp(Color4f &dst, Color4f &src, bool pp)
+ {
+ Float4 rcp = reciprocal(src.x, pp, true);
+
+ dst.x = rcp;
+ dst.y = rcp;
+ dst.z = rcp;
+ dst.w = rcp;
+ }
+
+ void ShaderCore::rsq(Color4f &dst, Color4f &src, bool pp)
+ {
+ Float4 rsq = reciprocalSquareRoot(src.x, true, pp);
+
+ dst.r = rsq;
+ dst.g = rsq;
+ dst.b = rsq;
+ dst.a = rsq;
+ }
+
+ void ShaderCore::dp3(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ Float4 dot = dot3(src0, src1);
+
+ dst.x = dot;
+ dst.y = dot;
+ dst.z = dot;
+ dst.w = dot;
+ }
+
+ void ShaderCore::dp4(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ Float4 dot = dot4(src0, src1);
+
+ dst.x = dot;
+ dst.y = dot;
+ dst.z = dot;
+ dst.w = dot;
+ }
+
+ void ShaderCore::min(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ dst.x = Min(src0.x, src1.x);
+ dst.y = Min(src0.y, src1.y);
+ dst.z = Min(src0.z, src1.z);
+ dst.w = Min(src0.w, src1.w);
+ }
+
+ void ShaderCore::max(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ dst.x = Max(src0.x, src1.x);
+ dst.y = Max(src0.y, src1.y);
+ dst.z = Max(src0.z, src1.z);
+ dst.w = Max(src0.w, src1.w);
+ }
+
+ void ShaderCore::slt(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ Int4 xMask = As<Int4>(CmpLT(src0.x, src1.x));
+ Int4 yMask = As<Int4>(CmpLT(src0.y, src1.y));
+ Int4 zMask = As<Int4>(CmpLT(src0.z, src1.z));
+ Int4 wMask = As<Int4>(CmpLT(src0.w, src1.w));
+
+ Int4 iOne = As<Int4>(Float4(1, 1, 1, 1));
+
+ dst.x = As<Float4>(xMask & iOne);
+ dst.y = As<Float4>(yMask & iOne);
+ dst.z = As<Float4>(zMask & iOne);
+ dst.w = As<Float4>(wMask & iOne);
+ }
+
+ void ShaderCore::sge(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ Int4 xMask = As<Int4>(CmpNLT(src0.x, src1.x));
+ Int4 yMask = As<Int4>(CmpNLT(src0.y, src1.y));
+ Int4 zMask = As<Int4>(CmpNLT(src0.z, src1.z));
+ Int4 wMask = As<Int4>(CmpNLT(src0.w, src1.w));
+
+ Int4 iOne = As<Int4>(Float4(1, 1, 1, 1));
+
+ dst.x = As<Float4>(xMask & iOne);
+ dst.y = As<Float4>(yMask & iOne);
+ dst.z = As<Float4>(zMask & iOne);
+ dst.w = As<Float4>(wMask & iOne);
+ }
+
+ void ShaderCore::exp(Color4f &dst, Color4f &src, bool pp)
+ {
+ Float4 exp = exponential(src.x, pp);
+
+ dst.x = exp;
+ dst.y = exp;
+ dst.z = exp;
+ dst.w = exp;
+ }
+
+ void ShaderCore::log(Color4f &dst, Color4f &src, bool pp)
+ {
+ Float4 log = logarithm(src.x, true, pp);
+
+ dst.x = log;
+ dst.y = log;
+ dst.z = log;
+ dst.w = log;
+ }
+
+ void ShaderCore::lit(Color4f &dst, Color4f &src)
+ {
+ dst.x = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ dst.y = Max(src.x, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+
+ Float4 pow;
+
+ pow = src.w;
+ pow = Min(pow, Float4(127.9961f, 127.9961f, 127.9961f, 127.9961f));
+ pow = Max(pow, Float4(-127.9961f, -127.9961f, -127.9961f, -127.9961f));
+
+ dst.z = power(src.y, pow);
+ dst.z = As<Float4>(As<Int4>(dst.z) & CmpNLT(src.x, Float4(0.0f, 0.0f, 0.0f, 0.0f)));
+ dst.z = As<Float4>(As<Int4>(dst.z) & CmpNLT(src.y, Float4(0.0f, 0.0f, 0.0f, 0.0f)));
+
+ dst.w = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ }
+
+ void ShaderCore::dst(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ dst.x = 1;
+ dst.y = src0.y * src1.y;
+ dst.z = src0.z;
+ dst.w = src1.w;
+ }
+
+ void ShaderCore::lrp(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2)
+ {
+ dst.x = src0.x * (src1.x - src2.x) + src2.x;
+ dst.y = src0.y * (src1.y - src2.y) + src2.y;
+ dst.z = src0.z * (src1.z - src2.z) + src2.z;
+ dst.w = src0.w * (src1.w - src2.w) + src2.w;
+ }
+
+ void ShaderCore::frc(Color4f &dst, Color4f &src)
+ {
+ dst.x = Fraction(src.x);
+ dst.y = Fraction(src.y);
+ dst.z = Fraction(src.z);
+ dst.w = Fraction(src.w);
+ }
+
+ void ShaderCore::pow(Color4f &dst, Color4f &src0, Color4f &src1, bool pp)
+ {
+ Float4 pow = power(src0.x, src1.x, pp);
+
+ dst.x = pow;
+ dst.y = pow;
+ dst.z = pow;
+ dst.w = pow;
+ }
+
+ void ShaderCore::crs(Color4f &dst, Color4f &src0, Color4f &src1)
+ {
+ dst.x = src0.y * src1.z - src0.z * src1.y;
+ dst.y = src0.z * src1.x - src0.x * src1.z;
+ dst.z = src0.x * src1.y - src0.y * src1.x;
+ }
+
+ void ShaderCore::sgn(Color4f &dst, Color4f &src)
+ {
+ sgn(dst.x, src.x);
+ sgn(dst.y, src.y);
+ sgn(dst.z, src.z);
+ sgn(dst.w, src.w);
+ }
+
+ void ShaderCore::abs(Color4f &dst, Color4f &src)
+ {
+ dst.x = Abs(src.x);
+ dst.y = Abs(src.y);
+ dst.z = Abs(src.z);
+ dst.w = Abs(src.w);
+ }
+
+ void ShaderCore::nrm(Color4f &dst, Color4f &src, bool pp)
+ {
+ Float4 dot = dot3(src, src);
+ Float4 rsq = reciprocalSquareRoot(dot, false, pp);
+
+ dst.x = src.x * rsq;
+ dst.y = src.y * rsq;
+ dst.z = src.z * rsq;
+ dst.w = src.w * rsq;
+ }
+
+ void ShaderCore::sincos(Color4f &dst, Color4f &src, bool pp)
+ {
+ Float4 tmp0;
+ Float4 tmp1;
+
+ tmp0 = src.x;
+
+ // cos(x) = sin(x + pi/2)
+ tmp0 += Float4(1.57079632e+0f);
+ tmp1 = As<Float4>(CmpNLT(tmp0, Float4(3.14159265e+0f)) & As<Int4>(Float4(6.28318530e+0f)));
+ tmp0 -= tmp1;
+
+ dst.x = sine(tmp0, pp);
+ dst.y = sine(src.x, pp);
+ }
+
+ void ShaderCore::expp(Color4f &dst, Color4f &src, unsigned short version)
+ {
+ if(version < 0x0200)
+ {
+ Float4 frc = Fraction(src.x);
+ Float4 floor = src.x - frc;
+
+ dst.x = exponential(floor, true);
+ dst.y = frc;
+ dst.z = exponential(src.x, true);
+ dst.w = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ }
+ else // Version >= 2.0
+ {
+ exp(dst, src, true); // FIXME: 10-bit precision suffices
+ }
+ }
+
+ void ShaderCore::logp(Color4f &dst, Color4f &src, unsigned short version)
+ {
+ if(version < 0x0200)
+ {
+ Float4 tmp0;
+ Float4 tmp1;
+ Float4 t;
+ Int4 r;
+
+ tmp0 = Abs(src.x);
+ tmp1 = tmp0;
+
+ // X component
+ r = As<Int4>(As<UInt4>(tmp0) >> 23) - Int4(127, 127, 127, 127);
+ dst.x = Float4(r);
+
+ // Y component
+ dst.y = As<Float4>((As<Int4>(tmp1) & Int4(0x007FFFFF)) | As<Int4>(Float4(1.0f)));
+
+ // Z component
+ dst.z = logarithm(src.x, true, true);
+
+ // W component
+ dst.w = 1.0f;
+ }
+ else
+ {
+ log(dst, src, true);
+ }
+ }
+
+ void ShaderCore::cmp(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2)
+ {
+ cmp(dst.x, src0.x, src1.x, src2.x);
+ cmp(dst.y, src0.y, src1.y, src2.y);
+ cmp(dst.z, src0.z, src1.z, src2.z);
+ cmp(dst.w, src0.w, src1.w, src2.w);
+ }
+
+ void ShaderCore::dp2add(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2)
+ {
+ Float4 t = src0.x * src1.x + src0.y * src1.y + src2.x;
+
+ dst.x = t;
+ dst.y = t;
+ dst.z = t;
+ dst.w = t;
+ }
+
+ void ShaderCore::sgn(Float4 &dst, Float4 &src)
+ {
+ Int4 neg = As<Int4>(CmpLT(src, Float4(0, 0, 0, 0))) & As<Int4>(Float4(-1, -1, -1, -1));
+ Int4 pos = As<Int4>(CmpNLT(src, Float4(0, 0, 0, 0))) & As<Int4>(Float4(1, 1, 1, 1));
+ dst = As<Float4>(neg | pos);
+ }
+
+ void ShaderCore::cmp(Float4 &dst, Float4 &src0, Float4 &src1, Float4 &src2)
+ {
+ Int4 pos = CmpNLE(Float4(0.0f, 0.0f, 0.0f, 0.0f), src0);
+ Int4 t0 = pos & As<Int4>(src2);
+ Int4 t1 = ~pos & As<Int4>(src1);
+ dst = As<Float4>(t0 | t1);
+ }
+
+ void ShaderCore::setp(Color4f &dst, Color4f &src0, Color4f &src1, Control control)
+ {
+ switch(control)
+ {
+ case Op::CONTROL_GT:
+ dst.x = As<Float4>(CmpNLE(src0.x, src1.x));
+ dst.y = As<Float4>(CmpNLE(src0.y, src1.y));
+ dst.z = As<Float4>(CmpNLE(src0.z, src1.z));
+ dst.w = As<Float4>(CmpNLE(src0.w, src1.w));
+ break;
+ case Op::CONTROL_EQ:
+ dst.x = As<Float4>(CmpEQ(src0.x, src1.x));
+ dst.y = As<Float4>(CmpEQ(src0.y, src1.y));
+ dst.z = As<Float4>(CmpEQ(src0.z, src1.z));
+ dst.w = As<Float4>(CmpEQ(src0.w, src1.w));
+ break;
+ case Op::CONTROL_GE:
+ dst.x = As<Float4>(CmpNLT(src0.x, src1.x));
+ dst.y = As<Float4>(CmpNLT(src0.y, src1.y));
+ dst.z = As<Float4>(CmpNLT(src0.z, src1.z));
+ dst.w = As<Float4>(CmpNLT(src0.w, src1.w));
+ break;
+ case Op::CONTROL_LT:
+ dst.x = As<Float4>(CmpLT(src0.x, src1.x));
+ dst.y = As<Float4>(CmpLT(src0.y, src1.y));
+ dst.z = As<Float4>(CmpLT(src0.z, src1.z));
+ dst.w = As<Float4>(CmpLT(src0.w, src1.w));
+ break;
+ case Op::CONTROL_NE:
+ dst.x = As<Float4>(CmpNEQ(src0.x, src1.x));
+ dst.y = As<Float4>(CmpNEQ(src0.y, src1.y));
+ dst.z = As<Float4>(CmpNEQ(src0.z, src1.z));
+ dst.w = As<Float4>(CmpNEQ(src0.w, src1.w));
+ break;
+ case Op::CONTROL_LE:
+ dst.x = As<Float4>(CmpLE(src0.x, src1.x));
+ dst.y = As<Float4>(CmpLE(src0.y, src1.y));
+ dst.z = As<Float4>(CmpLE(src0.z, src1.z));
+ dst.w = As<Float4>(CmpLE(src0.w, src1.w));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+}
diff --git a/src/Shader/ShaderCore.hpp b/src/Shader/ShaderCore.hpp
new file mode 100644
index 0000000..662e50a
--- /dev/null
+++ b/src/Shader/ShaderCore.hpp
@@ -0,0 +1,63 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_ShaderCore_hpp
+#define sw_ShaderCore_hpp
+
+#include "Shader.hpp"
+#include "Reactor/Reactor.hpp"
+
+namespace sw
+{
+ class ShaderCore
+ {
+ typedef Shader::Instruction::Operation::Control Control;
+ typedef Shader::Instruction::Operation Op;
+
+ public:
+ void mov(Color4f &dst, Color4f &src, bool floorToInteger = false);
+ void add(Color4f &dst, Color4f &src0, Color4f &src1);
+ void sub(Color4f &dst, Color4f &src0, Color4f &src1);
+ void mad(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2);
+ void mul(Color4f &dst, Color4f &src0, Color4f &src1);
+ void rcp(Color4f &dst, Color4f &src, bool pp = false);
+ void rsq(Color4f &dst, Color4f &src, bool pp = false);
+ void dp3(Color4f &dst, Color4f &src0, Color4f &src1);
+ void dp4(Color4f &dst, Color4f &src0, Color4f &src1);
+ void min(Color4f &dst, Color4f &src0, Color4f &src1);
+ void max(Color4f &dst, Color4f &src0, Color4f &src1);
+ void slt(Color4f &dst, Color4f &src0, Color4f &src1);
+ void sge(Color4f &dst, Color4f &src0, Color4f &src1);
+ void exp(Color4f &dst, Color4f &src, bool pp = false);
+ void log(Color4f &dst, Color4f &src, bool pp = false);
+ void lit(Color4f &dst, Color4f &src);
+ void dst(Color4f &dst, Color4f &src0, Color4f &src1);
+ void lrp(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2);
+ void frc(Color4f &dst, Color4f &src);
+ void pow(Color4f &dst, Color4f &src0, Color4f &src1, bool pp = false);
+ void crs(Color4f &dst, Color4f &src0, Color4f &src1);
+ void sgn(Color4f &dst, Color4f &src);
+ void abs(Color4f &dst, Color4f &src);
+ void nrm(Color4f &dst, Color4f &src, bool pp = false);
+ void sincos(Color4f &dst, Color4f &src, bool pp = false);
+ void expp(Color4f &dst, Color4f &src, unsigned short version);
+ void logp(Color4f &dst, Color4f &src, unsigned short version);
+ void cmp(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2);
+ void dp2add(Color4f &dst, Color4f &src0, Color4f &src1, Color4f &src2);
+ void setp(Color4f &dst, Color4f &src0, Color4f &src1, Control control);
+
+ private:
+ void sgn(Float4 &dst, Float4 &src);
+ void cmp(Float4 &dst, Float4 &src0, Float4 &src1, Float4 &src2);
+ };
+}
+
+#endif // sw_ShaderCore_hpp
diff --git a/src/Shader/VertexPipeline.cpp b/src/Shader/VertexPipeline.cpp
new file mode 100644
index 0000000..112b451
--- /dev/null
+++ b/src/Shader/VertexPipeline.cpp
@@ -0,0 +1,946 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "VertexPipeline.hpp"
+
+#include "Vertex.hpp"
+#include "Renderer.hpp"
+#include "Debug.hpp"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#undef max
+#undef min
+
+namespace sw
+{
+ VertexPipeline::VertexPipeline(const VertexProcessor::State &state) : VertexRoutine(state)
+ {
+ }
+
+ VertexPipeline::~VertexPipeline()
+ {
+ }
+
+ Color4f VertexPipeline::transformBlend(Registers &r, Color4f &src, Pointer<Byte> &matrix, bool homogeneous)
+ {
+ Color4f dst;
+
+ if(state.vertexBlendMatrixCount == 0)
+ {
+ dst = transform(src, matrix, homogeneous);
+ }
+ else
+ {
+ UInt index0[4];
+ UInt index1[4];
+ UInt index2[4];
+ UInt index3[4];
+
+ if(state.indexedVertexBlendEnable)
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ UInt indices;
+
+ switch(i)
+ {
+ case 0: indices = As<UInt>(Float(r.v[BlendIndices].x.x)); break;
+ case 1: indices = As<UInt>(Float(r.v[BlendIndices].x.y)); break;
+ case 2: indices = As<UInt>(Float(r.v[BlendIndices].x.z)); break;
+ case 3: indices = As<UInt>(Float(r.v[BlendIndices].x.w)); break;
+ }
+
+ index0[i] = (indices & UInt(0x000000FF)) << UInt(6); // FIXME: (indices & 0x000000FF) << 6
+ index1[i] = (indices & UInt(0x0000FF00)) >> UInt(2);
+ index2[i] = (indices & UInt(0x00FF0000)) >> UInt(10);
+ index3[i] = (indices & UInt(0xFF000000)) >> UInt(18);
+ }
+ }
+ else
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ index0[i] = Int(0 * 64); // FIXME: index0 = 0 * 64;
+ index1[i] = Int(1 * 64); // FIXME: index1 = 1 * 64;
+ index2[i] = Int(2 * 64); // FIXME: index2 = 2 * 64;
+ index3[i] = Int(3 * 64); // FIXME: index3 = 3 * 64;
+ }
+ }
+
+ Float4 weight0;
+ Float4 weight1;
+ Float4 weight2;
+ Float4 weight3;
+
+ switch(state.vertexBlendMatrixCount)
+ {
+ case 4: weight2 = r.v[BlendWeight].z;
+ case 3: weight1 = r.v[BlendWeight].y;
+ case 2: weight0 = r.v[BlendWeight].x;
+ case 1:
+ break;
+ }
+
+ if(state.vertexBlendMatrixCount == 1)
+ {
+ dst = transform(src, matrix, index0, homogeneous);
+ }
+ else if(state.vertexBlendMatrixCount == 2)
+ {
+ weight1 = Float4(1.0f) - weight0;
+
+ Color4f pos0;
+ Color4f pos1;
+
+ pos0 = transform(src, matrix, index0, homogeneous);
+ pos1 = transform(src, matrix, index1, homogeneous);
+
+ dst.x = pos0.x * weight0 + pos1.x * weight1; // FIXME: Color4f operators
+ dst.y = pos0.y * weight0 + pos1.y * weight1;
+ dst.z = pos0.z * weight0 + pos1.z * weight1;
+ dst.w = pos0.w * weight0 + pos1.w * weight1;
+ }
+ else if(state.vertexBlendMatrixCount == 3)
+ {
+ weight2 = Float4(1.0f) - (weight0 + weight1);
+
+ Color4f pos0;
+ Color4f pos1;
+ Color4f pos2;
+
+ pos0 = transform(src, matrix, index0, homogeneous);
+ pos1 = transform(src, matrix, index1, homogeneous);
+ pos2 = transform(src, matrix, index2, homogeneous);
+
+ dst.x = pos0.x * weight0 + pos1.x * weight1 + pos2.x * weight2;
+ dst.y = pos0.y * weight0 + pos1.y * weight1 + pos2.y * weight2;
+ dst.z = pos0.z * weight0 + pos1.z * weight1 + pos2.z * weight2;
+ dst.w = pos0.w * weight0 + pos1.w * weight1 + pos2.w * weight2;
+ }
+ else if(state.vertexBlendMatrixCount == 4)
+ {
+ weight3 = Float4(1.0f) - (weight0 + weight1 + weight2);
+
+ Color4f pos0;
+ Color4f pos1;
+ Color4f pos2;
+ Color4f pos3;
+
+ pos0 = transform(src, matrix, index0, homogeneous);
+ pos1 = transform(src, matrix, index1, homogeneous);
+ pos2 = transform(src, matrix, index2, homogeneous);
+ pos3 = transform(src, matrix, index3, homogeneous);
+
+ dst.x = pos0.x * weight0 + pos1.x * weight1 + pos2.x * weight2 + pos3.x * weight3;
+ dst.y = pos0.y * weight0 + pos1.y * weight1 + pos2.y * weight2 + pos3.y * weight3;
+ dst.z = pos0.z * weight0 + pos1.z * weight1 + pos2.z * weight2 + pos3.z * weight3;
+ dst.w = pos0.w * weight0 + pos1.w * weight1 + pos2.w * weight2 + pos3.w * weight3;
+ }
+ }
+
+ return dst;
+ }
+
+ void VertexPipeline::pipeline(Registers &r)
+ {
+ Color4f position;
+ Color4f normal;
+
+ if(!state.preTransformed)
+ {
+ position = transformBlend(r, r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.transformT)), true);
+ }
+ else
+ {
+ position = r.v[PositionT];
+ }
+
+ r.ox[Pos] = position.x;
+ r.oy[Pos] = position.y;
+ r.oz[Pos] = position.z;
+ r.ow[Pos] = position.w;
+
+ if(state.vertexNormalActive)
+ {
+ normal = transformBlend(r, r.v[Normal], Pointer<Byte>(r.data + OFFSET(DrawData,ff.normalTransformT)), false);
+
+ if(state.normalizeNormals)
+ {
+ normal = normalize(normal);
+ }
+ }
+
+ if(!state.vertexLightingActive)
+ {
+ // FIXME: Don't process if not used at all
+ if(state.diffuseActive && state.input[Color0])
+ {
+ Color4f diffuse = r.v[Color0];
+
+ r.ox[D0] = diffuse.x;
+ r.oy[D0] = diffuse.y;
+ r.oz[D0] = diffuse.z;
+ r.ow[D0] = diffuse.w;
+ }
+ else
+ {
+ r.ox[D0] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ r.oy[D0] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ r.oz[D0] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ r.ow[D0] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ }
+
+ // FIXME: Don't process if not used at all
+ if(state.specularActive && state.input[Color1])
+ {
+ Color4f specular = r.v[Color1];
+
+ r.ox[D1] = specular.x;
+ r.oy[D1] = specular.y;
+ r.oz[D1] = specular.z;
+ r.ow[D1] = specular.w;
+ }
+ else
+ {
+ r.ox[D1] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.oy[D1] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.oz[D1] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.ow[D1] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ }
+ }
+ else
+ {
+ Color4f diffuseSum;
+
+ r.ox[D0] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.oy[D0] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.oz[D0] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.ow[D0] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+ r.ox[D1] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.oy[D1] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.oz[D1] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.ow[D1] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+ diffuseSum.x = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ diffuseSum.y = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ diffuseSum.z = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ diffuseSum.w = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+ Color4f vertexPosition = transformBlend(r, r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+
+ for(int i = 0; i < 8; i++)
+ {
+ if(!(state.vertexLightActive & (1 << i)))
+ {
+ continue;
+ }
+
+ Color4f L; // Light vector
+ Float4 att; // Attenuation
+
+ // Attenuation
+ {
+ Float4 d; // Distance
+
+ L.x = L.y = L.z = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightPosition[i])); // FIXME: Unpack
+ L.x = L.x.xxxx;
+ L.y = L.y.yyyy;
+ L.z = L.z.zzzz;
+
+ L.x -= vertexPosition.x;
+ L.y -= vertexPosition.y;
+ L.z -= vertexPosition.z;
+ d = dot3(L, L);
+ d = RcpSqrt_pp(d); // FIXME: Sufficient precision?
+ L.x *= d;
+ L.y *= d;
+ L.z *= d;
+ d = Rcp_pp(d); // FIXME: Sufficient precision?
+
+ Float4 q = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.attenuationQuadratic[i]));
+ Float4 l = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.attenuationLinear[i]));
+ Float4 c = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.attenuationConstant[i]));
+
+ att = Rcp_pp((q * d + l) * d + c);
+ }
+
+ // Ambient per light
+ {
+ Float4 lightAmbient = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightAmbient[i])); // FIXME: Unpack
+
+ r.ox[D0] = r.ox[D0] + lightAmbient.x * att;
+ r.oy[D0] = r.oy[D0] + lightAmbient.y * att;
+ r.oz[D0] = r.oz[D0] + lightAmbient.z * att;
+ }
+
+ // Diffuse
+ if(state.vertexNormalActive)
+ {
+ Float4 dot;
+
+ dot = dot3(L, normal);
+ dot = Max(dot, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ dot *= att;
+
+ Color4f diff;
+
+ if(state.vertexDiffuseMaterialSourceActive == Context::MATERIAL)
+ {
+ diff.x = diff.y = diff.z = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialDiffuse)); // FIXME: Unpack
+ diff.x = diff.x.xxxx;
+ diff.y = diff.y.yyyy;
+ diff.z = diff.z.zzzz;
+ }
+ else if(state.vertexDiffuseMaterialSourceActive == Context::COLOR1)
+ {
+ diff = r.v[Color0];
+ }
+ else if(state.vertexDiffuseMaterialSourceActive == Context::COLOR2)
+ {
+ diff = r.v[Color1];
+ }
+ else ASSERT(false);
+
+ Float4 lightDiffuse = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightDiffuse[i]));
+
+ diffuseSum.x += diff.x * dot * lightDiffuse.x; // FIXME: Clamp first?
+ diffuseSum.y += diff.y * dot * lightDiffuse.y; // FIXME: Clamp first?
+ diffuseSum.z += diff.z * dot * lightDiffuse.z; // FIXME: Clamp first?
+ }
+
+ // Specular
+ if(state.vertexSpecularActive)
+ {
+ Color4f S;
+ Color4f C; // Camera vector
+ Float4 pow;
+
+ pow = *Pointer<Float>(r.data + OFFSET(DrawData,ff.materialShininess));
+
+ S.x = Float4(0.0f, 0.0f, 0.0f, 0.0f) - vertexPosition.x;
+ S.y = Float4(0.0f, 0.0f, 0.0f, 0.0f) - vertexPosition.y;
+ S.z = Float4(0.0f, 0.0f, 0.0f, 0.0f) - vertexPosition.z;
+ C = normalize(S);
+
+ S.x = L.x + C.x;
+ S.y = L.y + C.y;
+ S.z = L.z + C.z;
+ C = normalize(S);
+
+ Float4 dot = Max(dot3(C, normal), Float4(0.0f)); // FIXME: max(dot3(C, normal), 0)
+
+ Float4 P = power(dot, pow);
+ P *= att;
+
+ Color4f spec;
+
+ if(state.vertexSpecularMaterialSourceActive == Context::MATERIAL)
+ {
+ Float4 materialSpecular = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialSpecular)); // FIXME: Unpack
+
+ spec.x = materialSpecular.x;
+ spec.y = materialSpecular.y;
+ spec.z = materialSpecular.z;
+ }
+ else if(state.vertexSpecularMaterialSourceActive == Context::COLOR1)
+ {
+ spec = r.v[Color0];
+ }
+ else if(state.vertexSpecularMaterialSourceActive == Context::COLOR2)
+ {
+ spec = r.v[Color1];
+ }
+ else ASSERT(false);
+
+ Float4 lightSpecular = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.lightSpecular[i]));
+
+ spec.x *= lightSpecular.x;
+ spec.y *= lightSpecular.y;
+ spec.z *= lightSpecular.z;
+
+ spec.x *= P;
+ spec.y *= P;
+ spec.z *= P;
+
+ spec.x = Max(spec.x, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ spec.y = Max(spec.y, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ spec.z = Max(spec.z, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+
+ r.ox[D1] = r.ox[D1] + spec.x;
+ r.oy[D1] = r.oy[D1] + spec.y;
+ r.oz[D1] = r.oz[D1] + spec.z;
+ }
+ }
+
+ Float4 globalAmbient = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.globalAmbient)); // FIXME: Unpack
+
+ r.ox[D0] = r.ox[D0] + globalAmbient.x;
+ r.oy[D0] = r.oy[D0] + globalAmbient.y;
+ r.oz[D0] = r.oz[D0] + globalAmbient.z;
+
+ if(state.vertexAmbientMaterialSourceActive == Context::MATERIAL)
+ {
+ Float4 materialAmbient = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialAmbient)); // FIXME: Unpack
+
+ r.ox[D0] = r.ox[D0] * materialAmbient.x;
+ r.oy[D0] = r.oy[D0] * materialAmbient.y;
+ r.oz[D0] = r.oz[D0] * materialAmbient.z;
+ }
+ else if(state.vertexAmbientMaterialSourceActive == Context::COLOR1)
+ {
+ Color4f materialDiffuse = r.v[Color0];
+
+ r.ox[D0] = r.ox[D0] * materialDiffuse.x;
+ r.oy[D0] = r.oy[D0] * materialDiffuse.y;
+ r.oz[D0] = r.oz[D0] * materialDiffuse.z;
+ }
+ else if(state.vertexAmbientMaterialSourceActive == Context::COLOR2)
+ {
+ Color4f materialSpecular = r.v[Color1];
+
+ r.ox[D0] = r.ox[D0] * materialSpecular.x;
+ r.oy[D0] = r.oy[D0] * materialSpecular.y;
+ r.oz[D0] = r.oz[D0] * materialSpecular.z;
+ }
+ else ASSERT(false);
+
+ r.ox[D0] = r.ox[D0] + diffuseSum.x;
+ r.oy[D0] = r.oy[D0] + diffuseSum.y;
+ r.oz[D0] = r.oz[D0] + diffuseSum.z;
+
+ // Emissive
+ if(state.vertexEmissiveMaterialSourceActive == Context::MATERIAL)
+ {
+ Float4 materialEmission = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialEmission)); // FIXME: Unpack
+
+ r.ox[D0] = r.ox[D0] + materialEmission.x;
+ r.oy[D0] = r.oy[D0] + materialEmission.y;
+ r.oz[D0] = r.oz[D0] + materialEmission.z;
+ }
+ else if(state.vertexEmissiveMaterialSourceActive == Context::COLOR1)
+ {
+ Color4f materialSpecular = r.v[Color0];
+
+ r.ox[D0] = r.ox[D0] + materialSpecular.x;
+ r.oy[D0] = r.oy[D0] + materialSpecular.y;
+ r.oz[D0] = r.oz[D0] + materialSpecular.z;
+ }
+ else if(state.vertexEmissiveMaterialSourceActive == Context::COLOR2)
+ {
+ Color4f materialSpecular = r.v[Color1];
+
+ r.ox[D0] = r.ox[D0] + materialSpecular.x;
+ r.oy[D0] = r.oy[D0] + materialSpecular.y;
+ r.oz[D0] = r.oz[D0] + materialSpecular.z;
+ }
+ else ASSERT(false);
+
+ // Diffuse alpha component
+ if(state.vertexDiffuseMaterialSourceActive == Context::MATERIAL)
+ {
+ r.ow[D0] = Float4(*Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialDiffuse[0]))).wwww; // FIXME: Unpack
+ }
+ else if(state.vertexDiffuseMaterialSourceActive == Context::COLOR1)
+ {
+ Color4f alpha = r.v[Color0];
+ r.ow[D0] = alpha.w;
+ }
+ else if(state.vertexDiffuseMaterialSourceActive == Context::COLOR2)
+ {
+ Color4f alpha = r.v[Color1];
+ r.ow[D0] = alpha.w;
+ }
+ else ASSERT(false);
+
+ if(state.vertexSpecularActive)
+ {
+ // Specular alpha component
+ if(state.vertexSpecularMaterialSourceActive == Context::MATERIAL)
+ {
+ r.ow[D1] = Float4(*Pointer<Float4>(r.data + OFFSET(DrawData,ff.materialSpecular[3]))).wwww; // FIXME: Unpack
+ }
+ else if(state.vertexSpecularMaterialSourceActive == Context::COLOR1)
+ {
+ Color4f alpha = r.v[Color0];
+ r.ow[D1] = alpha.w;
+ }
+ else if(state.vertexSpecularMaterialSourceActive == Context::COLOR2)
+ {
+ Color4f alpha = r.v[Color1];
+ r.ow[D1] = alpha.w;
+ }
+ else ASSERT(false);
+ }
+ }
+
+ if(state.fogActive)
+ {
+ switch(state.vertexFogMode)
+ {
+ case Context::FOG_NONE:
+ if(state.specularActive)
+ {
+ r.ox[Fog] = r.ow[D1];
+ }
+ else
+ {
+ r.ox[Fog] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ }
+ break;
+ case Context::FOG_LINEAR:
+ case Context::FOG_EXP:
+ case Context::FOG_EXP2:
+ if(!state.rangeFogActive)
+ {
+ r.ox[Fog] = r.oz[Pos];
+ }
+ else
+ {
+ Color4f pos;
+
+ pos.x = r.ox[Pos];
+ pos.y = r.oy[Pos];
+ pos.z = r.oz[Pos];
+ pos.w = r.ow[Pos];
+
+ r.ox[Fog] = Sqrt(dot3(pos, pos)); // FIXME: oFog = length(o[Pos]);
+ }
+
+ r.ox[Fog] = r.ox[Fog] * *Pointer<Float4>(r.data + OFFSET(DrawData,fog.scale)) + *Pointer<Float4>(r.data + OFFSET(DrawData,fog.offset));
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+
+ for(int stage = 0; stage < 8; stage++)
+ {
+ processTextureCoordinate(r, stage, normal, position);
+ }
+
+ processPointSize(r);
+ }
+
+ void VertexPipeline::processTextureCoordinate(Registers &r, int stage, Color4f &normal, Color4f &position)
+ {
+ if(state.output[T0 + stage].write)
+ {
+ int i = state.textureState[stage].texCoordIndexActive;
+
+ switch(state.textureState[stage].texGenActive)
+ {
+ case Context::TEXGEN_PASSTHRU:
+ {
+ Color4f v = r.v[TexCoord0 + i];
+
+ r.ox[T0 + stage] = v.x;
+ r.oy[T0 + stage] = v.y;
+ r.oz[T0 + stage] = v.z;
+ r.ow[T0 + stage] = v.w;
+
+ if(state.input[TexCoord0 + i].type == STREAMTYPE_FLOAT)
+ {
+ switch(state.input[TexCoord0 + i].count)
+ {
+ case 1:
+ r.oy[T0 + stage] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ r.oz[T0 + stage] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ r.ow[T0 + stage] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ break;
+ case 2:
+ r.oz[T0 + stage] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ r.ow[T0 + stage] = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ break;
+ case 3:
+ r.ow[T0 + stage] = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case 4:
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ else ASSERT(!state.input[TexCoord0 + i]); // Point sprite; coordinates provided by setup
+ }
+ break;
+ case Context::TEXGEN_NORMAL:
+ {
+ Color4f Nc; // Normal vector in camera space
+
+ if(state.vertexNormalActive)
+ {
+ Nc = normal;
+ }
+ else
+ {
+ Nc.x = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ Nc.y = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ Nc.z = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ }
+
+ Nc.w = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+
+ r.ox[T0 + stage] = Nc.x;
+ r.oy[T0 + stage] = Nc.y;
+ r.oz[T0 + stage] = Nc.z;
+ r.ow[T0 + stage] = Nc.w;
+ }
+ break;
+ case Context::TEXGEN_POSITION:
+ {
+ Color4f Pn = transformBlend(r, r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true); // Position in camera space
+
+ Pn.w = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+
+ r.ox[T0 + stage] = Pn.x;
+ r.oy[T0 + stage] = Pn.y;
+ r.oz[T0 + stage] = Pn.z;
+ r.ow[T0 + stage] = Pn.w;
+ }
+ break;
+ case Context::TEXGEN_REFLECTION:
+ {
+ Color4f R; // Reflection vector
+
+ if(state.vertexNormalActive)
+ {
+ Color4f Nc; // Normal vector in camera space
+
+ Nc = normal;
+
+ if(state.localViewerActive)
+ {
+ Color4f Ec; // Eye vector in camera space
+ Color4f N2;
+
+ Ec = transformBlend(r, r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+ Ec = normalize(Ec);
+
+ // R = E - 2 * N * (E . N)
+ Float4 dot = Float4(2.0f, 2.0f, 2.0f, 2.0f) * dot3(Ec, Nc);
+
+ R.x = Ec.x - Nc.x * dot;
+ R.y = Ec.y - Nc.y * dot;
+ R.z = Ec.z - Nc.z * dot;
+ }
+ else
+ {
+ // u = -2 * Nz * Nx
+ // v = -2 * Nz * Ny
+ // w = 1 - 2 * Nz * Nz
+
+ R.x = -Float4(2.0f, 2.0f, 2.0f, 2.0f) * Nc.z * Nc.x;
+ R.y = -Float4(2.0f, 2.0f, 2.0f, 2.0f) * Nc.z * Nc.y;
+ R.z = Float4(1.0f, 1.0f, 1.0f, 1.0f) - Float4(2.0f, 2.0f, 2.0f, 2.0f) * Nc.z * Nc.z;
+ }
+ }
+ else
+ {
+ R.x = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ R.y = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ R.z = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ }
+
+ R.w = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+
+ r.ox[T0 + stage] = R.x;
+ r.oy[T0 + stage] = R.y;
+ r.oz[T0 + stage] = R.z;
+ r.ow[T0 + stage] = R.w;
+ }
+ break;
+ case Context::TEXGEN_SPHEREMAP:
+ {
+ Color4f R; // Reflection vector
+
+ if(state.vertexNormalActive)
+ {
+ Color4f Nc; // Normal vector in camera space
+
+ Nc = normal;
+
+ if(state.localViewerActive)
+ {
+ Color4f Ec; // Eye vector in camera space
+ Color4f N2;
+
+ Ec = transformBlend(r, r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+ Ec = normalize(Ec);
+
+ // R = E - 2 * N * (E . N)
+ Float4 dot = Float4(2.0f, 2.0f, 2.0f, 2.0f) * dot3(Ec, Nc);
+
+ R.x = Ec.x - Nc.x * dot;
+ R.y = Ec.y - Nc.y * dot;
+ R.z = Ec.z - Nc.z * dot;
+ }
+ else
+ {
+ // u = -2 * Nz * Nx
+ // v = -2 * Nz * Ny
+ // w = 1 - 2 * Nz * Nz
+
+ R.x = -Float4(2.0f, 2.0f, 2.0f, 2.0f) * Nc.z * Nc.x;
+ R.y = -Float4(2.0f, 2.0f, 2.0f, 2.0f) * Nc.z * Nc.y;
+ R.z = Float4(1.0f, 1.0f, 1.0f, 1.0f) - Float4(2.0f, 2.0f, 2.0f, 2.0f) * Nc.z * Nc.z;
+ }
+ }
+ else
+ {
+ R.x = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ R.y = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ R.z = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ }
+
+ R.z -= Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ R = normalize(R);
+ R.x = Float4(0.5f, 0.5f, 0.5f, 0.5f) * R.x + Float4(0.5f, 0.5f, 0.5f, 0.5f);
+ R.y = Float4(0.5f, 0.5f, 0.5f, 0.5f) * R.y + Float4(0.5f, 0.5f, 0.5f, 0.5f);
+
+ R.z = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+ R.w = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+ r.ox[T0 + stage] = R.x;
+ r.oy[T0 + stage] = R.y;
+ r.oz[T0 + stage] = R.z;
+ r.ow[T0 + stage] = R.w;
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ Color4f texTrans0;
+ Color4f texTrans1;
+ Color4f texTrans2;
+ Color4f texTrans3;
+
+ Color4f T;
+ Color4f t;
+
+ T.x = r.ox[T0 + stage];
+ T.y = r.oy[T0 + stage];
+ T.z = r.oz[T0 + stage];
+ T.w = r.ow[T0 + stage];
+
+ switch(state.textureState[stage].textureTransformCountActive)
+ {
+ case 4:
+ texTrans3.x = texTrans3.y = texTrans3.z = texTrans3.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][3])); // FIXME: Unpack
+ texTrans3.x = texTrans3.x.xxxx;
+ texTrans3.y = texTrans3.y.yyyy;
+ texTrans3.z = texTrans3.z.zzzz;
+ texTrans3.w = texTrans3.w.wwww;
+ t.w = dot4(T, texTrans3);
+ case 3:
+ texTrans2.x = texTrans2.y = texTrans2.z = texTrans2.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][2])); // FIXME: Unpack
+ texTrans2.x = texTrans2.x.xxxx;
+ texTrans2.y = texTrans2.y.yyyy;
+ texTrans2.z = texTrans2.z.zzzz;
+ texTrans2.w = texTrans2.w.wwww;
+ t.z = dot4(T, texTrans2);
+ case 2:
+ texTrans1.x = texTrans1.y = texTrans1.z = texTrans1.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][1])); // FIXME: Unpack
+ texTrans1.x = texTrans1.x.xxxx;
+ texTrans1.y = texTrans1.y.yyyy;
+ texTrans1.z = texTrans1.z.zzzz;
+ texTrans1.w = texTrans1.w.wwww;
+ t.y = dot4(T, texTrans1);
+ case 1:
+ texTrans0.x = texTrans0.y = texTrans0.z = texTrans0.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ff.textureTransform[stage][0])); // FIXME: Unpack
+ texTrans0.x = texTrans0.x.xxxx;
+ texTrans0.y = texTrans0.y.yyyy;
+ texTrans0.z = texTrans0.z.zzzz;
+ texTrans0.w = texTrans0.w.wwww;
+ t.x = dot4(T, texTrans0);
+
+ r.ox[T0 + stage] = t.x;
+ r.oy[T0 + stage] = t.y;
+ r.oz[T0 + stage] = t.z;
+ r.ow[T0 + stage] = t.w;
+ case 0:
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+
+ void VertexPipeline::processPointSize(Registers &r)
+ {
+ if(!state.pointSizeActive)
+ {
+ return; // Use global pointsize
+ }
+
+ if(state.input[PSize])
+ {
+ r.oy[Pts] = r.v[PSize].x;
+ }
+ else
+ {
+ r.oy[Pts] = *Pointer<Float4>(r.data + OFFSET(DrawData,point.pointSize));
+ }
+
+ if(state.pointScaleActive && !state.preTransformed)
+ {
+ Color4f p = transformBlend(r, r.v[Position], Pointer<Byte>(r.data + OFFSET(DrawData,ff.cameraTransformT)), true);
+
+ Float4 d = Sqrt(dot3(p, p)); // FIXME: length(p);
+
+ Float4 A = *Pointer<Float>(r.data + OFFSET(DrawData,point.pointScaleA)); // FIXME: Unpack
+ Float4 B = *Pointer<Float>(r.data + OFFSET(DrawData,point.pointScaleB)); // FIXME: Unpack
+ Float4 C = *Pointer<Float>(r.data + OFFSET(DrawData,point.pointScaleC)); // FIXME: Unpack
+
+ A = RcpSqrt_pp(A + d * (B + d * C));
+
+ r.oy[Pts] = r.oy[Pts] * Float4(*Pointer<Float>(r.data + OFFSET(DrawData,viewportHeight))) * A; // FIXME: Unpack
+ }
+ }
+
+ Color4f VertexPipeline::transform(Color4f &src, Pointer<Byte> &matrix, bool homogeneous)
+ {
+ Color4f dst;
+
+ Color4f row0;
+ Color4f row1;
+ Color4f row2;
+ Color4f row3;
+
+ if(homogeneous)
+ {
+ Float4 m[4][4];
+
+ for(int j = 0; j < 4; j++)
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ }
+ }
+
+ dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2] + m[0][3];
+ dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2] + m[1][3];
+ dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2] + m[2][3];
+ dst.w = src.x * m[3][0] + src.y * m[3][1] + src.z * m[3][2] + m[3][3];
+ }
+ else
+ {
+ Float4 m[3][3];
+
+ for(int j = 0; j < 3; j++)
+ {
+ for(int i = 0; i < 3; i++)
+ {
+ m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j);
+ }
+ }
+
+ dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2];
+ dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2];
+ dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2];
+ }
+
+ return dst;
+ }
+
+ Color4f VertexPipeline::transform(Color4f &src, Pointer<Byte> &matrix, UInt index[4], bool homogeneous)
+ {
+ Color4f dst;
+
+ Color4f row0;
+ Color4f row1;
+ Color4f row2;
+ Color4f row3;
+
+ if(homogeneous)
+ {
+ Float4 m[4][4];
+
+ for(int j = 0; j < 4; j++)
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j + index[0]);
+ m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j + index[1]);
+ m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j + index[2]);
+ m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j + index[3]);
+ }
+ }
+
+ dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2] + m[0][3];
+ dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2] + m[1][3];
+ dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2] + m[2][3];
+ dst.w = src.x * m[3][0] + src.y * m[3][1] + src.z * m[3][2] + m[3][3];
+ }
+ else
+ {
+ Float4 m[3][3];
+
+ for(int j = 0; j < 3; j++)
+ {
+ for(int i = 0; i < 3; i++)
+ {
+ m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j + index[0]);
+ m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j + index[1]);
+ m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j + index[2]);
+ m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j + index[3]);
+ }
+ }
+
+ dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2];
+ dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2];
+ dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2];
+ }
+
+ return dst;
+ }
+
+ Color4f VertexPipeline::normalize(Color4f &src)
+ {
+ Color4f dst;
+
+ Float4 rcpLength = RcpSqrt_pp(dot3(src, src));
+
+ dst.x = src.x * rcpLength;
+ dst.y = src.y * rcpLength;
+ dst.z = src.z * rcpLength;
+
+ return dst;
+ }
+
+ Float4 VertexPipeline::power(Float4 &src0, Float4 &src1)
+ {
+ Float4 dst = src0;
+
+ dst = dst * dst;
+ dst = dst * dst;
+ dst = Float4(As<Int4>(dst) - As<Int4>(Float4(1.0f, 1.0f, 1.0f, 1.0f)));
+
+ dst *= src1;
+
+ dst = As<Float4>(Int4(dst) + As<Int4>(Float4(1.0f, 1.0f, 1.0f, 1.0f)));
+ dst = RcpSqrt_pp(dst);
+ dst = RcpSqrt_pp(dst);
+
+ return dst;
+ }
+}
diff --git a/src/Shader/VertexPipeline.hpp b/src/Shader/VertexPipeline.hpp
new file mode 100644
index 0000000..efb8592
--- /dev/null
+++ b/src/Shader/VertexPipeline.hpp
@@ -0,0 +1,42 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_VertexPipeline_hpp
+#define sw_VertexPipeline_hpp
+
+#include "VertexRoutine.hpp"
+
+#include "Context.hpp"
+#include "VertexProcessor.hpp"
+
+namespace sw
+{
+ class VertexPipeline : public VertexRoutine
+ {
+ public:
+ VertexPipeline(const VertexProcessor::State &state);
+
+ virtual ~VertexPipeline();
+
+ private:
+ void pipeline(Registers &r);
+ void processTextureCoordinate(Registers &r, int stage, Color4f &normal, Color4f &position);
+ void processPointSize(Registers &r);
+
+ Color4f transformBlend(Registers &r, Color4f &src, Pointer<Byte> &matrix, bool homogenous);
+ Color4f transform(Color4f &src, Pointer<Byte> &matrix, bool homogenous);
+ Color4f transform(Color4f &src, Pointer<Byte> &matrix, UInt index[4], bool homogenous);
+ Color4f normalize(Color4f &src);
+ Float4 power(Float4 &src0, Float4 &src1);
+ };
+};
+
+#endif // sw_VertexPipeline_hpp
diff --git a/src/Shader/VertexProgram.cpp b/src/Shader/VertexProgram.cpp
new file mode 100644
index 0000000..41153bf
--- /dev/null
+++ b/src/Shader/VertexProgram.cpp
@@ -0,0 +1,1130 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "VertexProgram.hpp"
+
+#include "Renderer.hpp"
+#include "VertexShader.hpp"
+#include "Vertex.hpp"
+#include "Half.hpp"
+#include "SamplerCore.hpp"
+#include "Debug.hpp"
+
+extern bool localShaderConstants;
+
+namespace sw
+{
+ VertexProgram::VertexProgram(const VertexProcessor::State &state, const VertexShader *vertexShader) : VertexRoutine(state), vertexShader(vertexShader)
+ {
+ returns = false;
+ ifDepth = 0;
+ loopRepDepth = 0;
+ breakDepth = 0;
+
+ for(int i = 0; i < 2048; i++)
+ {
+ labelBlock[i] = 0;
+ }
+ }
+
+ VertexProgram::~VertexProgram()
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ delete sampler[i];
+ }
+ }
+
+ void VertexProgram::pipeline(Registers &r)
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ sampler[i] = new SamplerCore(r.constants, state.samplerState[i]);
+ }
+
+ if(!state.preTransformed)
+ {
+ shader(r);
+ }
+ else
+ {
+ passThrough(r);
+ }
+ }
+
+ Color4f VertexProgram::readConstant(Registers &r, const Src &src, int offset)
+ {
+ Color4f c;
+
+ int i = src.index + offset;
+ bool relative = src.relative;
+
+ if(!relative)
+ {
+ c.r = c.g = c.b = c.a = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c[i]));
+
+ c.r = c.r.xxxx;
+ c.g = c.g.yyyy;
+ c.b = c.b.zzzz;
+ c.a = c.a.wwww;
+
+ if(localShaderConstants) // Constant may be known at compile time
+ {
+ for(int j = 0; j < vertexShader->getLength(); j++)
+ {
+ const ShaderInstruction &instruction = *vertexShader->getInstruction(j);
+
+ if(instruction.getOpcode() == ShaderOperation::OPCODE_DEF)
+ {
+ if(instruction.getDestinationParameter().index == i)
+ {
+ c.r = Float4(instruction.getSourceParameter(0).value);
+ c.g = Float4(instruction.getSourceParameter(1).value);
+ c.b = Float4(instruction.getSourceParameter(2).value);
+ c.a = Float4(instruction.getSourceParameter(3).value);
+
+ break;
+ }
+ }
+ }
+ }
+ }
+ else if(src.relativeType == Src::PARAMETER_LOOP)
+ {
+ Int loopCounter = r.aL[r.loopDepth];
+
+ c.r = c.g = c.b = c.a = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c[i]) + loopCounter * 16);
+
+ c.r = c.r.xxxx;
+ c.g = c.g.yyyy;
+ c.b = c.b.zzzz;
+ c.a = c.a.wwww;
+ }
+ else
+ {
+ Int index0;
+ Int index1;
+ Int index2;
+ Int index3;
+
+ Float4 a0_;
+
+ switch(src.relativeSwizzle & 0x03)
+ {
+ case 0: a0_ = r.a0.x; break;
+ case 1: a0_ = r.a0.y; break;
+ case 2: a0_ = r.a0.z; break;
+ case 3: a0_ = r.a0.w; break;
+ }
+
+ index0 = i + RoundInt(Float(a0_.x));
+ index1 = i + RoundInt(Float(a0_.y));
+ index2 = i + RoundInt(Float(a0_.z));
+ index3 = i + RoundInt(Float(a0_.w));
+
+ // Clamp to constant register range, c[256] = {0, 0, 0, 0}
+ index0 = IfThenElse(UInt(index0) > UInt(256), Int(256), index0);
+ index1 = IfThenElse(UInt(index1) > UInt(256), Int(256), index1);
+ index2 = IfThenElse(UInt(index2) > UInt(256), Int(256), index2);
+ index3 = IfThenElse(UInt(index3) > UInt(256), Int(256), index3);
+
+ c.x = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index0 * 16, 16);
+ c.y = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index1 * 16, 16);
+ c.z = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index2 * 16, 16);
+ c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,vs.c) + index3 * 16, 16);
+
+ transpose4x4(c.x, c.y, c.z, c.w);
+ }
+
+ return c;
+ }
+
+ void VertexProgram::shader(Registers &r)
+ {
+ // vertexShader->print("VertexShader-%0.16llX.txt", state.shaderHash);
+
+ unsigned short version = vertexShader->getVersion();
+
+ r.enableIndex = 0;
+ r.stackIndex = 0;
+
+ for(int i = 0; i < vertexShader->getLength(); i++)
+ {
+ const ShaderInstruction *instruction = vertexShader->getInstruction(i);
+ Op::Opcode opcode = instruction->getOpcode();
+
+ // #ifndef NDEBUG // FIXME: Centralize debug output control
+ // vertexShader->printInstruction(i, "debug.txt");
+ // #endif
+
+ if(opcode == Op::OPCODE_DCL || opcode == Op::OPCODE_DEF || opcode == Op::OPCODE_DEFI || opcode == Op::OPCODE_DEFB)
+ {
+ continue;
+ }
+
+ Dst dest = instruction->getDestinationParameter();
+ Src src0 = instruction->getSourceParameter(0);
+ Src src1 = instruction->getSourceParameter(1);
+ Src src2 = instruction->getSourceParameter(2);
+ Src src3 = instruction->getSourceParameter(3);
+
+ bool predicate = instruction->isPredicate();
+ int size = vertexShader->size(opcode);
+ Usage usage = instruction->getUsage();
+ unsigned char usageIndex = instruction->getUsageIndex();
+ Control control = instruction->getControl();
+ bool integer = dest.type == Dst::PARAMETER_ADDR;
+ bool pp = dest.partialPrecision;
+
+ Color4f d;
+ Color4f s0;
+ Color4f s1;
+ Color4f s2;
+ Color4f s3;
+
+ if(src0.type != Src::PARAMETER_VOID) s0 = reg(r, src0);
+ if(src1.type != Src::PARAMETER_VOID) s1 = reg(r, src1);
+ if(src2.type != Src::PARAMETER_VOID) s2 = reg(r, src2);
+ if(src3.type != Src::PARAMETER_VOID) s3 = reg(r, src3);
+
+ switch(opcode)
+ {
+ case Op::OPCODE_VS_1_0: break;
+ case Op::OPCODE_VS_1_1: break;
+ case Op::OPCODE_VS_2_0: break;
+ case Op::OPCODE_VS_2_x: break;
+ case Op::OPCODE_VS_2_sw: break;
+ case Op::OPCODE_VS_3_0: break;
+ case Op::OPCODE_VS_3_sw: break;
+ case Op::OPCODE_DCL: break;
+ case Op::OPCODE_DEF: break;
+ case Op::OPCODE_DEFI: break;
+ case Op::OPCODE_DEFB: break;
+ case Op::OPCODE_NOP: break;
+ case Op::OPCODE_ABS: abs(d, s0); break;
+ case Op::OPCODE_ADD: add(d, s0, s1); break;
+ case Op::OPCODE_CRS: crs(d, s0, s1); break;
+ case Op::OPCODE_DP3: dp3(d, s0, s1); break;
+ case Op::OPCODE_DP4: dp4(d, s0, s1); break;
+ case Op::OPCODE_DST: dst(d, s0, s1); break;
+ case Op::OPCODE_EXP: exp(d, s0, pp); break;
+ case Op::OPCODE_EXPP: expp(d, s0, version); break;
+ case Op::OPCODE_FRC: frc(d, s0); break;
+ case Op::OPCODE_LIT: lit(d, s0); break;
+ case Op::OPCODE_LOG: log(d, s0, pp); break;
+ case Op::OPCODE_LOGP: logp(d, s0, version); break;
+ case Op::OPCODE_LRP: lrp(d, s0, s1, s2); break;
+ case Op::OPCODE_M3X2: M3X2(r, d, s0, src1); break;
+ case Op::OPCODE_M3X3: M3X3(r, d, s0, src1); break;
+ case Op::OPCODE_M3X4: M3X4(r, d, s0, src1); break;
+ case Op::OPCODE_M4X3: M4X3(r, d, s0, src1); break;
+ case Op::OPCODE_M4X4: M4X4(r, d, s0, src1); break;
+ case Op::OPCODE_MAD: mad(d, s0, s1, s2); break;
+ case Op::OPCODE_MAX: max(d, s0, s1); break;
+ case Op::OPCODE_MIN: min(d, s0, s1); break;
+ case Op::OPCODE_MOV: mov(d, s0, integer); break;
+ case Op::OPCODE_MOVA: mov(d, s0); break;
+ case Op::OPCODE_MUL: mul(d, s0, s1); break;
+ case Op::OPCODE_NRM: nrm(d, s0, pp); break;
+ case Op::OPCODE_POW: pow(d, s0, s1, pp); break;
+ case Op::OPCODE_RCP: rcp(d, s0, pp); break;
+ case Op::OPCODE_RSQ: rsq(d, s0, pp); break;
+ case Op::OPCODE_SGE: sge(d, s0, s1); break;
+ case Op::OPCODE_SGN: sgn(d, s0); break;
+ case Op::OPCODE_SINCOS: sincos(d, s0, pp); break;
+ case Op::OPCODE_SLT: slt(d, s0, s1); break;
+ case Op::OPCODE_SUB: sub(d, s0, s1); break;
+ case Op::OPCODE_BREAK: BREAK(r); break;
+ case Op::OPCODE_BREAKC: BREAKC(r, s0, s1, control); break;
+ case Op::OPCODE_BREAKP: BREAKP(r, src0); break;
+ case Op::OPCODE_CALL: CALL(r, dest.index); break;
+ case Op::OPCODE_CALLNZ: CALLNZ(r, dest.index, src0); break;
+ case Op::OPCODE_ELSE: ELSE(r); break;
+ case Op::OPCODE_ENDIF: ENDIF(r); break;
+ case Op::OPCODE_ENDLOOP: ENDLOOP(r); break;
+ case Op::OPCODE_ENDREP: ENDREP(r); break;
+ case Op::OPCODE_IF: IF(r, src0); break;
+ case Op::OPCODE_IFC: IFC(r, s0, s1, control); break;
+ case Op::OPCODE_LABEL: LABEL(dest.index); break;
+ case Op::OPCODE_LOOP: LOOP(r, src1); break;
+ case Op::OPCODE_REP: REP(r, src0); break;
+ case Op::OPCODE_RET: RET(r); break;
+ case Op::OPCODE_SETP: setp(d, s0, s1, control); break;
+ case Op::OPCODE_TEXLDL: TEXLDL(r, d, s0, src1); break;
+ case Op::OPCODE_END: break;
+ default:
+ ASSERT(false);
+ }
+
+ if(dest.type != Dst::PARAMETER_VOID && dest.type != Dst::PARAMETER_LABEL)
+ {
+ if(dest.saturate)
+ {
+ if(dest.x) d.r = Max(d.r, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ if(dest.y) d.g = Max(d.g, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ if(dest.z) d.b = Max(d.b, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ if(dest.w) d.a = Max(d.a, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+
+ if(dest.x) d.r = Min(d.r, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ if(dest.y) d.g = Min(d.g, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ if(dest.z) d.b = Min(d.b, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ if(dest.w) d.a = Min(d.a, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ }
+
+ if(vertexShader->containsDynamicBranching())
+ {
+ Color4f pDst; // FIXME: Rename
+
+ switch(dest.type)
+ {
+ case Dst::PARAMETER_VOID: break;
+ case Dst::PARAMETER_TEMP: pDst = r.r[dest.index]; break;
+ case Dst::PARAMETER_ADDR: pDst = r.a0; break;
+ case Dst::PARAMETER_RASTOUT:
+ switch(dest.index)
+ {
+ case 0:
+ if(dest.x) pDst.x = r.ox[Pos];
+ if(dest.y) pDst.y = r.oy[Pos];
+ if(dest.z) pDst.z = r.oz[Pos];
+ if(dest.w) pDst.w = r.ow[Pos];
+ break;
+ case 1:
+ pDst.x = r.ox[Fog];
+ break;
+ case 2:
+ pDst.x = r.oy[Pts];
+ break;
+ default:
+ ASSERT(false);
+ }
+ break;
+ case Dst::PARAMETER_ATTROUT:
+ if(dest.x) pDst.x = r.ox[D0 + dest.index];
+ if(dest.y) pDst.y = r.oy[D0 + dest.index];
+ if(dest.z) pDst.z = r.oz[D0 + dest.index];
+ if(dest.w) pDst.w = r.ow[D0 + dest.index];
+ break;
+ case Dst::PARAMETER_TEXCRDOUT:
+ // case Dst::PARAMETER_OUTPUT:
+ if(version < 0x0300)
+ {
+ if(dest.x) pDst.x = r.ox[T0 + dest.index];
+ if(dest.y) pDst.y = r.oy[T0 + dest.index];
+ if(dest.z) pDst.z = r.oz[T0 + dest.index];
+ if(dest.w) pDst.w = r.ow[T0 + dest.index];
+ }
+ else
+ {
+ if(!dest.relative)
+ {
+ if(dest.x) pDst.x = r.ox[dest.index];
+ if(dest.y) pDst.y = r.oy[dest.index];
+ if(dest.z) pDst.z = r.oz[dest.index];
+ if(dest.w) pDst.w = r.ow[dest.index];
+ }
+ else
+ {
+ Int aL = r.aL[r.loopDepth];
+
+ if(dest.x) pDst.x = r.ox[dest.index + aL];
+ if(dest.y) pDst.y = r.oy[dest.index + aL];
+ if(dest.z) pDst.z = r.oz[dest.index + aL];
+ if(dest.w) pDst.w = r.ow[dest.index + aL];
+ }
+ }
+ break;
+ case Dst::PARAMETER_LABEL: break;
+ case Dst::PARAMETER_PREDICATE: pDst = r.p0; break;
+ case Dst::PARAMETER_INPUT: break;
+ default:
+ ASSERT(false);
+ }
+
+ Int4 enable = r.enableStack[r.enableIndex] & r.enableBreak;
+
+ Int4 xEnable = enable;
+ Int4 yEnable = enable;
+ Int4 zEnable = enable;
+ Int4 wEnable = enable;
+
+ if(predicate)
+ {
+ unsigned char pSwizzle = instruction->getPredicateSwizzle();
+
+ Float4 xPredicate = r.p0[(pSwizzle >> 0) & 0x03];
+ Float4 yPredicate = r.p0[(pSwizzle >> 2) & 0x03];
+ Float4 zPredicate = r.p0[(pSwizzle >> 4) & 0x03];
+ Float4 wPredicate = r.p0[(pSwizzle >> 6) & 0x03];
+
+ if(!instruction->isPredicateNot())
+ {
+ if(dest.x) xEnable = xEnable & As<Int4>(xPredicate);
+ if(dest.y) yEnable = yEnable & As<Int4>(yPredicate);
+ if(dest.z) zEnable = zEnable & As<Int4>(zPredicate);
+ if(dest.w) wEnable = wEnable & As<Int4>(wPredicate);
+ }
+ else
+ {
+ if(dest.x) xEnable = xEnable & ~As<Int4>(xPredicate);
+ if(dest.y) yEnable = yEnable & ~As<Int4>(yPredicate);
+ if(dest.z) zEnable = zEnable & ~As<Int4>(zPredicate);
+ if(dest.w) wEnable = wEnable & ~As<Int4>(wPredicate);
+ }
+ }
+
+ if(dest.x) d.x = As<Float4>(As<Int4>(d.x) & xEnable);
+ if(dest.y) d.y = As<Float4>(As<Int4>(d.y) & yEnable);
+ if(dest.z) d.z = As<Float4>(As<Int4>(d.z) & zEnable);
+ if(dest.w) d.w = As<Float4>(As<Int4>(d.w) & wEnable);
+
+ if(dest.x) d.x = As<Float4>(As<Int4>(d.x) | (As<Int4>(pDst.x) & ~xEnable));
+ if(dest.y) d.y = As<Float4>(As<Int4>(d.y) | (As<Int4>(pDst.y) & ~yEnable));
+ if(dest.z) d.z = As<Float4>(As<Int4>(d.z) | (As<Int4>(pDst.z) & ~zEnable));
+ if(dest.w) d.w = As<Float4>(As<Int4>(d.w) | (As<Int4>(pDst.w) & ~wEnable));
+ }
+
+ switch(dest.type)
+ {
+ case Dst::PARAMETER_VOID:
+ break;
+ case Dst::PARAMETER_TEMP:
+ if(dest.x) r.r[dest.index].x = d.x;
+ if(dest.y) r.r[dest.index].y = d.y;
+ if(dest.z) r.r[dest.index].z = d.z;
+ if(dest.w) r.r[dest.index].w = d.w;
+ break;
+ case Dst::PARAMETER_ADDR:
+ if(dest.x) r.a0.x = d.x;
+ if(dest.y) r.a0.y = d.y;
+ if(dest.z) r.a0.z = d.z;
+ if(dest.w) r.a0.w = d.w;
+ break;
+ case Dst::PARAMETER_RASTOUT:
+ switch(dest.index)
+ {
+ case 0:
+ if(dest.x) r.ox[Pos] = d.x;
+ if(dest.y) r.oy[Pos] = d.y;
+ if(dest.z) r.oz[Pos] = d.z;
+ if(dest.w) r.ow[Pos] = d.w;
+ break;
+ case 1:
+ r.ox[Fog] = d.x;
+ break;
+ case 2:
+ r.oy[Pts] = d.x;
+ break;
+ default: ASSERT(false);
+ }
+ break;
+ case Dst::PARAMETER_ATTROUT:
+ if(dest.x) r.ox[D0 + dest.index] = d.x;
+ if(dest.y) r.oy[D0 + dest.index] = d.y;
+ if(dest.z) r.oz[D0 + dest.index] = d.z;
+ if(dest.w) r.ow[D0 + dest.index] = d.w;
+ break;
+ case Dst::PARAMETER_TEXCRDOUT:
+ // case Dst::PARAMETER_OUTPUT:
+ if(version < 0x0300)
+ {
+ if(dest.x) r.ox[T0 + dest.index] = d.x;
+ if(dest.y) r.oy[T0 + dest.index] = d.y;
+ if(dest.z) r.oz[T0 + dest.index] = d.z;
+ if(dest.w) r.ow[T0 + dest.index] = d.w;
+ }
+ else
+ {
+ if(!dest.relative)
+ {
+ if(dest.x) r.ox[dest.index] = d.x;
+ if(dest.y) r.oy[dest.index] = d.y;
+ if(dest.z) r.oz[dest.index] = d.z;
+ if(dest.w) r.ow[dest.index] = d.w;
+ }
+ else
+ {
+ Int aL = r.aL[r.loopDepth];
+
+ if(dest.x) r.ox[dest.index + aL] = d.x;
+ if(dest.y) r.oy[dest.index + aL] = d.y;
+ if(dest.z) r.oz[dest.index + aL] = d.z;
+ if(dest.w) r.ow[dest.index + aL] = d.w;
+ }
+ }
+ break;
+ case Dst::PARAMETER_LABEL: break;
+ case Dst::PARAMETER_PREDICATE: r.p0 = d; break;
+ case Dst::PARAMETER_INPUT: break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+
+ if(returns)
+ {
+ Nucleus::setInsertBlock(returnBlock);
+ }
+ }
+
+ void VertexProgram::passThrough(Registers &r)
+ {
+ if(vertexShader)
+ {
+ for(int i = 0; i < 12; i++)
+ {
+ unsigned char usage = vertexShader->output[i][0].usage;
+ unsigned char index = vertexShader->output[i][0].index;
+
+ switch(usage)
+ {
+ case 0xFF:
+ continue;
+ case ShaderOperation::USAGE_PSIZE:
+ r.oy[i] = r.v[i].x;
+ break;
+ case ShaderOperation::USAGE_TEXCOORD:
+ r.ox[i] = r.v[i].x;
+ r.oy[i] = r.v[i].y;
+ r.oz[i] = r.v[i].z;
+ r.ow[i] = r.v[i].w;
+ break;
+ case ShaderOperation::USAGE_POSITION:
+ r.ox[i] = r.v[i].x;
+ r.oy[i] = r.v[i].y;
+ r.oz[i] = r.v[i].z;
+ r.ow[i] = r.v[i].w;
+ break;
+ case ShaderOperation::USAGE_COLOR:
+ r.ox[i] = r.v[i].x;
+ r.oy[i] = r.v[i].y;
+ r.oz[i] = r.v[i].z;
+ r.ow[i] = r.v[i].w;
+ break;
+ case ShaderOperation::USAGE_FOG:
+ r.ox[i] = r.v[i].x;
+ break;
+ default:
+ ASSERT(false);
+ }
+ }
+ }
+ else
+ {
+ r.ox[Pos] = r.v[PositionT].x;
+ r.oy[Pos] = r.v[PositionT].y;
+ r.oz[Pos] = r.v[PositionT].z;
+ r.ow[Pos] = r.v[PositionT].w;
+
+ for(int i = 0; i < 2; i++)
+ {
+ r.ox[D0 + i] = r.v[Color0 + i].x;
+ r.oy[D0 + i] = r.v[Color0 + i].y;
+ r.oz[D0 + i] = r.v[Color0 + i].z;
+ r.ow[D0 + i] = r.v[Color0 + i].w;
+ }
+
+ for(int i = 0; i < 8; i++)
+ {
+ r.ox[T0 + i] = r.v[TexCoord0 + i].x;
+ r.oy[T0 + i] = r.v[TexCoord0 + i].y;
+ r.oz[T0 + i] = r.v[TexCoord0 + i].z;
+ r.ow[T0 + i] = r.v[TexCoord0 + i].w;
+ }
+
+ r.oy[Pts] = r.v[PSize].x;
+ }
+ }
+
+ Color4f VertexProgram::reg(Registers &r, const Src &src, int offset)
+ {
+ int i = src.index + offset;
+
+ Color4f reg;
+
+ if(src.type == Src::PARAMETER_CONST)
+ {
+ reg = readConstant(r, src, offset);
+ }
+
+ switch(src.type)
+ {
+ case Src::PARAMETER_TEMP: reg = r.r[i]; break;
+ case Src::PARAMETER_CONST: break;
+ case Src::PARAMETER_INPUT: reg = r.v[i]; break;
+ case Src::PARAMETER_VOID: return r.r[0]; // Dummy
+ case Src::PARAMETER_FLOATLITERAL: return r.r[0]; // Dummy
+ case Src::PARAMETER_ADDR: reg = r.a0; break;
+ case Src::PARAMETER_CONSTBOOL: return r.r[0]; // Dummy
+ case Src::PARAMETER_CONSTINT: return r.r[0]; // Dummy
+ case Src::PARAMETER_LOOP: return r.r[0]; // Dummy
+ case Src::PARAMETER_PREDICATE: return r.r[0]; // Dummy
+ case Src::PARAMETER_SAMPLER: return r.r[0]; // Dummy
+ default:
+ ASSERT(false);
+ }
+
+ Color4f mod;
+
+ mod.x = reg[(src.swizzle >> 0) & 0x03];
+ mod.y = reg[(src.swizzle >> 2) & 0x03];
+ mod.z = reg[(src.swizzle >> 4) & 0x03];
+ mod.w = reg[(src.swizzle >> 6) & 0x03];
+
+ switch(src.modifier)
+ {
+ case Src::MODIFIER_NONE:
+ break;
+ case Src::MODIFIER_NEGATE:
+ mod.x = -mod.x;
+ mod.y = -mod.y;
+ mod.z = -mod.z;
+ mod.w = -mod.w;
+ break;
+ case Src::MODIFIER_BIAS:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_BIAS_NEGATE:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_SIGN:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_SIGN_NEGATE:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_COMPLEMENT:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_X2:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_X2_NEGATE:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_DZ:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_DW:
+ ASSERT(false); // NOTE: Unimplemented
+ break;
+ case Src::MODIFIER_ABS:
+ mod.x = Abs(mod.x);
+ mod.y = Abs(mod.y);
+ mod.z = Abs(mod.z);
+ mod.w = Abs(mod.w);
+ break;
+ case Src::MODIFIER_ABS_NEGATE:
+ mod.x = -Abs(mod.x);
+ mod.y = -Abs(mod.y);
+ mod.z = -Abs(mod.z);
+ mod.w = -Abs(mod.w);
+ break;
+ case Src::MODIFIER_NOT:
+ UNIMPLEMENTED();
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ return mod;
+ }
+
+ void VertexProgram::M3X2(Registers &r, Color4f &dst, Color4f &src0, Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+
+ dst.x = dot3(src0, row0);
+ dst.y = dot3(src0, row1);
+ }
+
+ void VertexProgram::M3X3(Registers &r, Color4f &dst, Color4f &src0, Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+
+ dst.x = dot3(src0, row0);
+ dst.y = dot3(src0, row1);
+ dst.z = dot3(src0, row2);
+ }
+
+ void VertexProgram::M3X4(Registers &r, Color4f &dst, Color4f &src0, Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+ Color4f row3 = reg(r, src1, 3);
+
+ dst.x = dot3(src0, row0);
+ dst.y = dot3(src0, row1);
+ dst.z = dot3(src0, row2);
+ dst.w = dot3(src0, row3);
+ }
+
+ void VertexProgram::M4X3(Registers &r, Color4f &dst, Color4f &src0, Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+
+ dst.x = dot4(src0, row0);
+ dst.y = dot4(src0, row1);
+ dst.z = dot4(src0, row2);
+ }
+
+ void VertexProgram::M4X4(Registers &r, Color4f &dst, Color4f &src0, Src &src1)
+ {
+ Color4f row0 = reg(r, src1, 0);
+ Color4f row1 = reg(r, src1, 1);
+ Color4f row2 = reg(r, src1, 2);
+ Color4f row3 = reg(r, src1, 3);
+
+ dst.x = dot4(src0, row0);
+ dst.y = dot4(src0, row1);
+ dst.z = dot4(src0, row2);
+ dst.w = dot4(src0, row3);
+ }
+
+ void VertexProgram::BREAK(Registers &r)
+ {
+ llvm::BasicBlock *deadBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+ if(breakDepth == 0)
+ {
+ Nucleus::createBr(endBlock);
+ }
+ else
+ {
+ r.enableBreak = r.enableBreak & ~r.enableStack[r.enableIndex];
+ Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+ branch(allBreak, endBlock, deadBlock);
+ }
+
+ Nucleus::setInsertBlock(deadBlock);
+ }
+
+ void VertexProgram::BREAKC(Registers &r, Color4f &src0, Color4f &src1, Control control)
+ {
+ Int4 condition;
+
+ switch(control)
+ {
+ case Op::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+ case Op::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x); break;
+ case Op::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+ case Op::CONTROL_LT: condition = CmpLT(src0.x, src1.x); break;
+ case Op::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+ case Op::CONTROL_LE: condition = CmpLE(src0.x, src1.x); break;
+ default:
+ ASSERT(false);
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+ r.enableBreak = r.enableBreak & ~condition;
+ Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+ branch(allBreak, endBlock, continueBlock);
+ Nucleus::setInsertBlock(continueBlock);
+ }
+
+ void VertexProgram::BREAKP(Registers &r, const Src &predicateRegister) // FIXME: Factor out parts common with BREAKC
+ {
+ Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+ if(predicateRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = ~condition;
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+ r.enableBreak = r.enableBreak & ~condition;
+ Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+ branch(allBreak, endBlock, continueBlock);
+ Nucleus::setInsertBlock(continueBlock);
+ }
+
+ void VertexProgram::CALL(Registers &r, int labelIndex)
+ {
+ if(!labelBlock[labelIndex])
+ {
+ labelBlock[labelIndex] = Nucleus::createBasicBlock();
+ }
+
+ llvm::BasicBlock *retBlock = Nucleus::createBasicBlock();
+ callRetBlock.push_back(retBlock);
+
+ r.callStack[r.stackIndex++] = UInt((unsigned int)callRetBlock.size() - 1); // FIXME
+
+ Nucleus::createBr(labelBlock[labelIndex]);
+ Nucleus::setInsertBlock(retBlock);
+ }
+
+ void VertexProgram::CALLNZ(Registers &r, int labelIndex, const Src &src)
+ {
+ if(src.type == Src::PARAMETER_CONSTBOOL)
+ {
+ CALLNZb(r, labelIndex, src);
+ }
+ else if(src.type == Src::PARAMETER_PREDICATE)
+ {
+ CALLNZp(r, labelIndex, src);
+ }
+ else ASSERT(false);
+ }
+
+ void VertexProgram::CALLNZb(Registers &r, int labelIndex, const Src &boolRegister)
+ {
+ Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0)); // FIXME
+
+ if(boolRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = !condition;
+ }
+
+ if(!labelBlock[labelIndex])
+ {
+ labelBlock[labelIndex] = Nucleus::createBasicBlock();
+ }
+
+ llvm::BasicBlock *retBlock = Nucleus::createBasicBlock();
+ callRetBlock.push_back(retBlock);
+
+ r.callStack[r.stackIndex++] = UInt((int)callRetBlock.size() - 1); // FIXME
+
+ branch(condition, labelBlock[labelIndex], retBlock);
+ Nucleus::setInsertBlock(retBlock);
+ }
+
+ void VertexProgram::CALLNZp(Registers &r, int labelIndex, const Src &predicateRegister)
+ {
+ Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+ if(predicateRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = ~condition;
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ if(!labelBlock[labelIndex])
+ {
+ labelBlock[labelIndex] = Nucleus::createBasicBlock();
+ }
+
+ llvm::BasicBlock *retBlock = Nucleus::createBasicBlock();
+ callRetBlock.push_back(retBlock);
+
+ r.callStack[r.stackIndex++] = UInt((int)callRetBlock.size() - 1); // FIXME
+
+ r.enableIndex++;
+ r.enableStack[r.enableIndex] = condition;
+
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, labelBlock[labelIndex], retBlock);
+ Nucleus::setInsertBlock(retBlock);
+
+ r.enableIndex--;
+ }
+
+ void VertexProgram::ELSE(Registers &r)
+ {
+ ifDepth--;
+
+ llvm::BasicBlock *falseBlock = ifFalseBlock[ifDepth];
+ llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+ if(isConditionalIf[ifDepth])
+ {
+ Int4 condition = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, falseBlock, endBlock);
+
+ r.enableStack[r.enableIndex] = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+ }
+ else
+ {
+ Nucleus::createBr(endBlock);
+ Nucleus::setInsertBlock(falseBlock);
+ }
+
+ ifFalseBlock[ifDepth] = endBlock;
+
+ ifDepth++;
+ }
+
+ void VertexProgram::ENDIF(Registers &r)
+ {
+ ifDepth--;
+
+ llvm::BasicBlock *endBlock = ifFalseBlock[ifDepth];
+
+ Nucleus::createBr(endBlock);
+ Nucleus::setInsertBlock(endBlock);
+
+ if(isConditionalIf[ifDepth])
+ {
+ breakDepth--;
+ r.enableIndex--;
+ }
+ }
+
+ void VertexProgram::ENDREP(Registers &r)
+ {
+ loopRepDepth--;
+
+ llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(endBlock);
+
+ r.loopDepth--;
+ r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ void VertexProgram::ENDLOOP(Registers &r)
+ {
+ loopRepDepth--;
+
+ r.aL[r.loopDepth] = r.aL[r.loopDepth] + r.increment[r.loopDepth]; // FIXME: +=
+
+ llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+ llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(endBlock);
+
+ r.loopDepth--;
+ r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ void VertexProgram::IF(Registers &r, const Src &src)
+ {
+ if(src.type == Src::PARAMETER_CONSTBOOL)
+ {
+ IFb(r, src);
+ }
+ else if(src.type == Src::PARAMETER_PREDICATE)
+ {
+ IFp(r, src);
+ }
+ else ASSERT(false);
+ }
+
+ void VertexProgram::IFb(Registers &r, const Src &boolRegister)
+ {
+ ASSERT(ifDepth < 24 + 4);
+
+ Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0)); // FIXME
+
+ if(boolRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = !condition;
+ }
+
+ llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+ branch(condition, trueBlock, falseBlock);
+
+ isConditionalIf[ifDepth] = false;
+ ifFalseBlock[ifDepth] = falseBlock;
+
+ ifDepth++;
+ }
+
+ void VertexProgram::IFp(Registers &r, const Src &predicateRegister) // FIXME: Factor out parts common with IFC
+ {
+ Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+ if(predicateRegister.modifier == Src::MODIFIER_NOT)
+ {
+ condition = ~condition;
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ r.enableIndex++;
+ r.enableStack[r.enableIndex] = condition;
+
+ llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, trueBlock, falseBlock);
+
+ isConditionalIf[ifDepth] = true;
+ ifFalseBlock[ifDepth] = falseBlock;
+
+ ifDepth++;
+ breakDepth++;
+ }
+
+ void VertexProgram::IFC(Registers &r, Color4f &src0, Color4f &src1, Control control)
+ {
+ Int4 condition;
+
+ switch(control)
+ {
+ case Op::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+ case Op::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x); break;
+ case Op::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+ case Op::CONTROL_LT: condition = CmpLT(src0.x, src1.x); break;
+ case Op::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+ case Op::CONTROL_LE: condition = CmpLE(src0.x, src1.x); break;
+ default:
+ ASSERT(false);
+ }
+
+ condition &= r.enableStack[r.enableIndex];
+
+ r.enableIndex++;
+ r.enableStack[r.enableIndex] = condition;
+
+ llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+ Bool notAllFalse = SignMask(condition & r.enableBreak) != 0;
+
+ branch(notAllFalse, trueBlock, falseBlock);
+
+ isConditionalIf[ifDepth] = true;
+ ifFalseBlock[ifDepth] = falseBlock;
+
+ ifDepth++;
+ breakDepth++;
+ }
+
+ void VertexProgram::LABEL(int labelIndex)
+ {
+ Nucleus::setInsertBlock(labelBlock[labelIndex]);
+ }
+
+ void VertexProgram::LOOP(Registers &r, const Src &integerRegister)
+ {
+ r.loopDepth++;
+
+ r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
+ r.aL[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][1]));
+ r.increment[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][2]));
+
+ // FIXME: Compiles to two instructions?
+ If(r.increment[r.loopDepth] == 0)
+ {
+ r.increment[r.loopDepth] = 1;
+ }
+
+ llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+ loopRepTestBlock[loopRepDepth] = testBlock;
+ loopRepEndBlock[loopRepDepth] = endBlock;
+
+ // FIXME: jump(testBlock)
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(testBlock);
+
+ branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+ Nucleus::setInsertBlock(loopBlock);
+
+ r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1; // FIXME: --
+
+ loopRepDepth++;
+ breakDepth = 0;
+ }
+
+ void VertexProgram::REP(Registers &r, const Src &integerRegister)
+ {
+ r.loopDepth++;
+
+ r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
+ r.aL[r.loopDepth] = r.aL[r.loopDepth - 1];
+
+ llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
+ llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+ loopRepTestBlock[loopRepDepth] = testBlock;
+ loopRepEndBlock[loopRepDepth] = endBlock;
+
+ // FIXME: jump(testBlock)
+ Nucleus::createBr(testBlock);
+ Nucleus::setInsertBlock(testBlock);
+
+ branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+ Nucleus::setInsertBlock(loopBlock);
+
+ r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1; // FIXME: --
+
+ loopRepDepth++;
+ breakDepth = 0;
+ }
+
+ void VertexProgram::RET(Registers &r)
+ {
+ if(!returns)
+ {
+ returnBlock = Nucleus::createBasicBlock();
+ Nucleus::createBr(returnBlock);
+
+ returns = true;
+ }
+ else
+ {
+ // FIXME: Encapsulate
+ UInt index = r.callStack[--r.stackIndex];
+
+ llvm::BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
+ llvm::Value *value = Nucleus::createLoad(index.address);
+ llvm::Value *switchInst = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock.size());
+
+ for(unsigned int i = 0; i < callRetBlock.size(); i++)
+ {
+ Nucleus::addSwitchCase(switchInst, i, callRetBlock[i]);
+ }
+
+ Nucleus::setInsertBlock(unreachableBlock);
+ Nucleus::createUnreachable();
+ }
+ }
+
+ void VertexProgram::TEXLDL(Registers &r, Color4f &dst, Color4f &src0, const Src &src1)
+ {
+ Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap[16]) + src1.index * sizeof(Texture);
+
+ Color4f tmp;
+
+ sampler[src1.index]->sampleTexture(texture, tmp, src0.x, src0.y, src0.z, src0.w, src0, src0, false, false, true);
+
+ dst.x = tmp[(src1.swizzle >> 0) & 0x3];
+ dst.y = tmp[(src1.swizzle >> 2) & 0x3];
+ dst.z = tmp[(src1.swizzle >> 4) & 0x3];
+ dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+ }
+}
diff --git a/src/Shader/VertexProgram.hpp b/src/Shader/VertexProgram.hpp
new file mode 100644
index 0000000..bae97f3
--- /dev/null
+++ b/src/Shader/VertexProgram.hpp
@@ -0,0 +1,94 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_VertexProgram_hpp
+#define sw_VertexProgram_hpp
+
+#include "VertexRoutine.hpp"
+#include "ShaderCore.hpp"
+
+#include "Stream.hpp"
+#include "Types.hpp"
+
+namespace sw
+{
+ struct Stream;
+ class VertexShader;
+ class SamplerCore;
+
+ class VertexProgram : public VertexRoutine, public ShaderCore
+ {
+ public:
+ VertexProgram(const VertexProcessor::State &state, const VertexShader *vertexShader);
+
+ virtual ~VertexProgram();
+
+ private:
+ typedef Shader::Instruction::DestinationParameter Dst;
+ typedef Shader::Instruction::SourceParameter Src;
+ typedef Shader::Instruction::Operation Op;
+ typedef Shader::Instruction::Operation::Control Control;
+ typedef Shader::Instruction::Operation::Usage Usage;
+
+ Color4f readConstant(Registers &r, const Src &src, int offset = 0);
+ void pipeline(Registers &r);
+ void shader(Registers &r);
+ void passThrough(Registers &r);
+
+ Color4f reg(Registers &r, const Src &src, int offset = 0);
+
+ void M3X2(Registers &r, Color4f &dst, Color4f &src0, Src &src1);
+ void M3X3(Registers &r, Color4f &dst, Color4f &src0, Src &src1);
+ void M3X4(Registers &r, Color4f &dst, Color4f &src0, Src &src1);
+ void M4X3(Registers &r, Color4f &dst, Color4f &src0, Src &src1);
+ void M4X4(Registers &r, Color4f &dst, Color4f &src0, Src &src1);
+ void BREAK(Registers &r);
+ void BREAKC(Registers &r, Color4f &src0, Color4f &src1, Control);
+ void BREAKP(Registers &r, const Src &predicateRegister);
+ void CALL(Registers &r, int labelIndex);
+ void CALLNZ(Registers &r, int labelIndex, const Src &src);
+ void CALLNZb(Registers &r, int labelIndex, const Src &boolRegister);
+ void CALLNZp(Registers &r, int labelIndex, const Src &predicateRegister);
+ void ELSE(Registers &r);
+ void ENDIF(Registers &r);
+ void ENDLOOP(Registers &r);
+ void ENDREP(Registers &r);
+ void IF(Registers &r, const Src &src);
+ void IFb(Registers &r, const Src &boolRegister);
+ void IFp(Registers &r, const Src &predicateRegister);
+ void IFC(Registers &r, Color4f &src0, Color4f &src1, Control);
+ void LABEL(int labelIndex);
+ void LOOP(Registers &r, const Src &integerRegister);
+ void REP(Registers &r, const Src &integerRegister);
+ void RET(Registers &r);
+ void TEXLDL(Registers &r, Color4f &dst, Color4f &src, const Src&);
+
+ SamplerCore *sampler[4];
+
+ bool returns;
+ int ifDepth;
+ int loopRepDepth;
+ int breakDepth;
+
+ // FIXME: Get rid of llvm::
+ llvm::BasicBlock *ifFalseBlock[24 + 24];
+ llvm::BasicBlock *loopRepTestBlock[4];
+ llvm::BasicBlock *loopRepEndBlock[4];
+ llvm::BasicBlock *labelBlock[2048];
+ std::vector<llvm::BasicBlock*> callRetBlock;
+ llvm::BasicBlock *returnBlock;
+ bool isConditionalIf[24 + 24];
+
+ const VertexShader *const vertexShader;
+ };
+}
+
+#endif // sw_VertexProgram_hpp
diff --git a/src/Shader/VertexRoutine.cpp b/src/Shader/VertexRoutine.cpp
new file mode 100644
index 0000000..f28a741
--- /dev/null
+++ b/src/Shader/VertexRoutine.cpp
@@ -0,0 +1,605 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "VertexRoutine.hpp"
+
+#include "VertexShader.hpp"
+#include "Vertex.hpp"
+#include "Half.hpp"
+#include "Renderer.hpp"
+#include "Constants.hpp"
+#include "Debug.hpp"
+
+namespace sw
+{
+ VertexRoutine::VertexRoutine(const VertexProcessor::State &state) : state(state)
+ {
+ routine = 0;
+ }
+
+ VertexRoutine::~VertexRoutine()
+ {
+ }
+
+ void VertexRoutine::generate()
+ {
+ Function<Void, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>> function;
+ {
+ Pointer<Byte> vertex(function.arg(0));
+ Pointer<Byte> batch(function.arg(1));
+ Pointer<Byte> task(function.arg(2));
+ Pointer<Byte> data(function.arg(3));
+
+ const bool texldl = state.shaderContainsTexldl;
+
+ Pointer<Byte> cache = task + OFFSET(VertexTask,vertexCache);
+ Pointer<Byte> vertexCache = cache + OFFSET(VertexCache,vertex);
+ Pointer<Byte> tagCache = cache + OFFSET(VertexCache,tag);
+
+ UInt count = *Pointer<UInt>(task+ OFFSET(VertexTask,count));
+
+ Registers r;
+ r.data = data;
+ r.constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
+
+ Do
+ {
+ UInt index = *Pointer<UInt>(batch);
+ UInt tagIndex = index & UInt(0x0000003C);
+ UInt indexQ = !texldl ? index & UInt(0xFFFFFFFC) : index; // FIXME: TEXLDL hack to have independent LODs, hurts performance.
+
+ If(*Pointer<UInt>(tagCache + tagIndex) != indexQ)
+ {
+ *Pointer<UInt>(tagCache + tagIndex) = indexQ;
+
+ readInput(r, indexQ);
+ pipeline(r);
+ postTransform(r);
+ computeClipFlags(r);
+
+ Pointer<Byte> cacheLine0 = vertexCache + tagIndex * UInt((int)sizeof(Vertex));
+ writeCache(cacheLine0, r);
+ }
+
+ UInt cacheIndex = index & UInt(0x0000003F);
+ Pointer<Byte> cacheLine = vertexCache + cacheIndex * UInt((int)sizeof(Vertex));
+ writeVertex(vertex, cacheLine);
+
+ vertex += sizeof(Vertex);
+ batch += sizeof(unsigned int);
+ count--;
+ }
+ Until(count == UInt(0))
+
+ Return();
+ }
+
+ routine = function(L"VertexRoutine_%0.16llX", state.shaderHash);
+ }
+
+ Routine *VertexRoutine::getRoutine()
+ {
+ return routine;
+ }
+
+ void VertexRoutine::readInput(Registers &r, UInt &index)
+ {
+ for(int i = 0; i < 16; i++)
+ {
+ Pointer<Byte> input = *Pointer<Pointer<Byte>>(r.data + OFFSET(DrawData,input) + sizeof(void*) * i);
+ UInt stride = *Pointer<UInt>(r.data + OFFSET(DrawData,stride) + sizeof(unsigned int) * i);
+
+ r.v[i] = readStream(r, input, stride, state.input[i], index);
+ }
+ }
+
+ void VertexRoutine::computeClipFlags(Registers &r)
+ {
+ int pos = state.positionRegister;
+
+ // Backtransform
+ if(state.preTransformed)
+ {
+ Float4 rhw = Float4(1.0f, 1.0f, 1.0f, 1.0f) / r.ow[pos];
+
+ Float4 W = *Pointer<Float4>(r.data + OFFSET(DrawData,WWWWx16)) * Float4(1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f);
+ Float4 H = *Pointer<Float4>(r.data + OFFSET(DrawData,HHHHx16)) * Float4(1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f);
+ Float4 L = *Pointer<Float4>(r.data + OFFSET(DrawData,LLLLx16)) * Float4(1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f);
+ Float4 T = *Pointer<Float4>(r.data + OFFSET(DrawData,TTTTx16)) * Float4(1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f);
+
+ r.ox[pos] = (r.ox[pos] - L) / W * rhw;
+ r.oy[pos] = (r.oy[pos] - T) / H * rhw;
+ r.oz[pos] = r.oz[pos] * rhw;
+ r.ow[pos] = rhw;
+ }
+
+ if(state.superSampling)
+ {
+ r.ox[pos] = r.ox[pos] + *Pointer<Float4>(r.data + OFFSET(DrawData,XXXX)) * r.ow[pos];
+ r.oy[pos] = r.oy[pos] + *Pointer<Float4>(r.data + OFFSET(DrawData,YYYY)) * r.ow[pos];
+ }
+
+ Float4 clipX = r.ox[pos];
+ Float4 clipY = r.oy[pos];
+
+ if(state.multiSampling) // Clip at pixel edges instead of pixel centers
+ {
+ clipX += *Pointer<Float4>(r.data + OFFSET(DrawData,offX)) * r.ow[pos];
+ clipY += *Pointer<Float4>(r.data + OFFSET(DrawData,offY)) * r.ow[pos];
+ }
+
+ Int4 maxX = CmpLT(r.ow[pos], clipX);
+ Int4 maxY = CmpLT(r.ow[pos], clipY);
+ Int4 maxZ = CmpLT(r.ow[pos], r.oz[pos]);
+
+ Int4 minX = CmpNLE(-r.ow[pos], clipX);
+ Int4 minY = CmpNLE(-r.ow[pos], clipY);
+ Int4 minZ = CmpNLE(Float4(0.0f, 0.0f, 0.0f, 0.0f), r.oz[pos]);
+
+ Int flags;
+
+ flags = SignMask(maxX);
+ r.clipFlags = *Pointer<Int>(r.constants + OFFSET(Constants,maxX) + flags * 4); // FIXME: Array indexing
+ flags = SignMask(maxY);
+ r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,maxY) + flags * 4);
+ flags = SignMask(maxZ);
+ r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,maxZ) + flags * 4);
+ flags = SignMask(minX);
+ r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,minX) + flags * 4);
+ flags = SignMask(minY);
+ r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,minY) + flags * 4);
+ flags = SignMask(minZ);
+ r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,minZ) + flags * 4);
+
+ Int4 finiteX = CmpLE(Abs(r.ox[pos]), *Pointer<Float4>(r.constants + OFFSET(Constants,maxPos)));
+ Int4 finiteY = CmpLE(Abs(r.oy[pos]), *Pointer<Float4>(r.constants + OFFSET(Constants,maxPos)));
+ Int4 finiteZ = CmpLE(Abs(r.oz[pos]), *Pointer<Float4>(r.constants + OFFSET(Constants,maxPos)));
+
+ flags = SignMask(finiteX & finiteY & finiteZ);
+ r.clipFlags |= *Pointer<Int>(r.constants + OFFSET(Constants,fini) + flags * 4);
+
+ if(state.preTransformed)
+ {
+ r.clipFlags &= 0xFBFBFBFB; // Don't clip against far clip plane
+ }
+ }
+
+ Color4f VertexRoutine::readStream(Registers &r, Pointer<Byte> &buffer, UInt &stride, const Stream &stream, const UInt &index)
+ {
+ const bool texldl = state.shaderContainsTexldl;
+
+ Color4f v;
+
+ Pointer<Byte> source0 = buffer + index * stride;
+ Pointer<Byte> source1 = source0 + (!texldl ? stride : 0);
+ Pointer<Byte> source2 = source1 + (!texldl ? stride : 0);
+ Pointer<Byte> source3 = source2 + (!texldl ? stride : 0);
+
+ switch(stream.type)
+ {
+ case STREAMTYPE_FLOAT:
+ {
+ if(stream.count == 0)
+ {
+ // Null stream, all default components
+ }
+ else if(stream.count == 1)
+ {
+ v.x.x = *Pointer<Float>(source0);
+ v.x.y = *Pointer<Float>(source1);
+ v.x.z = *Pointer<Float>(source2);
+ v.x.w = *Pointer<Float>(source3);
+ }
+ else
+ {
+ v.x = *Pointer<Float4>(source0);
+ v.y = *Pointer<Float4>(source1);
+ v.z = *Pointer<Float4>(source2);
+ v.w = *Pointer<Float4>(source3);
+
+ transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+ }
+ }
+ break;
+ case STREAMTYPE_BYTE:
+ {
+ v.x = Float4(*Pointer<Byte4>(source0));
+ v.y = Float4(*Pointer<Byte4>(source1));
+ v.z = Float4(*Pointer<Byte4>(source2));
+ v.w = Float4(*Pointer<Byte4>(source3));
+
+ transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+ if(stream.normalized)
+ {
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ }
+ }
+ break;
+ case STREAMTYPE_SBYTE:
+ {
+ v.x = Float4(*Pointer<SByte4>(source0));
+ v.y = Float4(*Pointer<SByte4>(source1));
+ v.z = Float4(*Pointer<SByte4>(source2));
+ v.w = Float4(*Pointer<SByte4>(source3));
+
+ transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+ if(stream.normalized)
+ {
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleSByte));
+ }
+ }
+ break;
+ case STREAMTYPE_COLOR:
+ {
+ v.x = Float4(*Pointer<Byte4>(source0)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ v.y = Float4(*Pointer<Byte4>(source1)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ v.z = Float4(*Pointer<Byte4>(source2)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+ v.w = Float4(*Pointer<Byte4>(source3)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleByte));
+
+ transpose4x4(v.x, v.y, v.z, v.w);
+
+ // Swap red and blue
+ Float4 t = v.x;
+ v.x = v.z;
+ v.z = t;
+ }
+ break;
+ case STREAMTYPE_SHORT:
+ {
+ v.x = Float4(*Pointer<Short4>(source0));
+ v.y = Float4(*Pointer<Short4>(source1));
+ v.z = Float4(*Pointer<Short4>(source2));
+ v.w = Float4(*Pointer<Short4>(source3));
+
+ transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+ if(stream.normalized)
+ {
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleShort));
+ }
+ }
+ break;
+ case STREAMTYPE_USHORT:
+ {
+ v.x = Float4(*Pointer<UShort4>(source0));
+ v.y = Float4(*Pointer<UShort4>(source1));
+ v.z = Float4(*Pointer<UShort4>(source2));
+ v.w = Float4(*Pointer<UShort4>(source3));
+
+ transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+ if(stream.normalized)
+ {
+ if(stream.count >= 1) v.x *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
+ if(stream.count >= 2) v.y *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
+ if(stream.count >= 3) v.z *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
+ if(stream.count >= 4) v.w *= *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleUShort));
+ }
+ }
+ break;
+ case STREAMTYPE_UDEC3:
+ {
+ // FIXME: Vectorize
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source0);
+
+ v.x.x = Float(x & 0x000003FF);
+ v.x.y = Float(y & 0x000FFC00);
+ v.x.z = Float(z & 0x3FF00000);
+ }
+
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source1);
+
+ v.y.x = Float(x & 0x000003FF);
+ v.y.y = Float(y & 0x000FFC00);
+ v.y.z = Float(z & 0x3FF00000);
+ }
+
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source2);
+
+ v.z.x = Float(x & 0x000003FF);
+ v.z.y = Float(y & 0x000FFC00);
+ v.z.z = Float(z & 0x3FF00000);
+ }
+
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source3);
+
+ v.w.x = Float(x & 0x000003FF);
+ v.w.y = Float(y & 0x000FFC00);
+ v.w.z = Float(z & 0x3FF00000);
+ }
+
+ transpose4x3(v.x, v.y, v.z, v.w);
+
+ v.y *= Float4(1.0f / 0x00000400, 1.0f / 0x00000400, 1.0f / 0x00000400, 1.0f / 0x00000400);
+ v.z *= Float4(1.0f / 0x00100000, 1.0f / 0x00100000, 1.0f / 0x00100000, 1.0f / 0x00100000);
+ }
+ break;
+ case STREAMTYPE_DEC3N:
+ {
+ // FIXME: Vectorize
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source0);
+
+ v.x.x = Float((x << 22) & 0xFFC00000);
+ v.x.y = Float((y << 12) & 0xFFC00000);
+ v.x.z = Float((z << 2) & 0xFFC00000);
+ }
+
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source1);
+
+ v.y.x = Float((x << 22) & 0xFFC00000);
+ v.y.y = Float((y << 12) & 0xFFC00000);
+ v.y.z = Float((z << 2) & 0xFFC00000);
+ }
+
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source2);
+
+ v.z.x = Float((x << 22) & 0xFFC00000);
+ v.z.y = Float((y << 12) & 0xFFC00000);
+ v.z.z = Float((z << 2) & 0xFFC00000);
+ }
+
+ {
+ Int x, y, z;
+
+ x = y = z = *Pointer<Int>(source3);
+
+ v.w.x = Float((x << 22) & 0xFFC00000);
+ v.w.y = Float((y << 12) & 0xFFC00000);
+ v.w.z = Float((z << 2) & 0xFFC00000);
+ }
+
+ transpose4x3(v.x, v.y, v.z, v.w);
+
+ v.x *= Float4(1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f);
+ v.y *= Float4(1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f);
+ v.z *= Float4(1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f, 1.0f / 0x00400000 / 511.0f);
+ }
+ break;
+ case STREAMTYPE_FIXED:
+ {
+ v.x = Float4(*Pointer<Int4>(source0)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
+ v.y = Float4(*Pointer<Int4>(source1)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
+ v.z = Float4(*Pointer<Int4>(source2)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
+ v.w = Float4(*Pointer<Int4>(source3)) * *Pointer<Float4>(r.constants + OFFSET(Constants,unscaleFixed));
+
+ transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+ }
+ break;
+ case STREAMTYPE_HALF:
+ {
+ if(stream.count >= 1)
+ {
+ UShort x0 = *Pointer<UShort>(source0 + 0);
+ UShort x1 = *Pointer<UShort>(source1 + 0);
+ UShort x2 = *Pointer<UShort>(source2 + 0);
+ UShort x3 = *Pointer<UShort>(source3 + 0);
+
+ v.x.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x0) * 4);
+ v.x.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x1) * 4);
+ v.x.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x2) * 4);
+ v.x.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(x3) * 4);
+ }
+
+ if(stream.count >= 2)
+ {
+ UShort y0 = *Pointer<UShort>(source0 + 2);
+ UShort y1 = *Pointer<UShort>(source1 + 2);
+ UShort y2 = *Pointer<UShort>(source2 + 2);
+ UShort y3 = *Pointer<UShort>(source3 + 2);
+
+ v.y.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y0) * 4);
+ v.y.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y1) * 4);
+ v.y.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y2) * 4);
+ v.y.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(y3) * 4);
+ }
+
+ if(stream.count >= 3)
+ {
+ UShort z0 = *Pointer<UShort>(source0 + 4);
+ UShort z1 = *Pointer<UShort>(source1 + 4);
+ UShort z2 = *Pointer<UShort>(source2 + 4);
+ UShort z3 = *Pointer<UShort>(source3 + 4);
+
+ v.z.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z0) * 4);
+ v.z.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z1) * 4);
+ v.z.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z2) * 4);
+ v.z.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(z3) * 4);
+ }
+
+ if(stream.count >= 4)
+ {
+ UShort w0 = *Pointer<UShort>(source0 + 6);
+ UShort w1 = *Pointer<UShort>(source1 + 6);
+ UShort w2 = *Pointer<UShort>(source2 + 6);
+ UShort w3 = *Pointer<UShort>(source3 + 6);
+
+ v.w.x = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w0) * 4);
+ v.w.y = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w1) * 4);
+ v.w.z = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w2) * 4);
+ v.w.w = *Pointer<Float>(r.constants + OFFSET(Constants,half2float) + Int(w3) * 4);
+ }
+ }
+ break;
+ case STREAMTYPE_INDICES:
+ {
+ v.x.x = *Pointer<Float>(source0);
+ v.x.y = *Pointer<Float>(source1);
+ v.x.z = *Pointer<Float>(source2);
+ v.x.w = *Pointer<Float>(source3);
+ }
+ break;
+ default:
+ ASSERT(false);
+ }
+
+ if(stream.count < 1) v.x = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ if(stream.count < 2) v.y = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ if(stream.count < 3) v.z = Float4(0.0f, 0.0f, 0.0f, 0.0f);
+ if(stream.count < 4) v.w = Float4(1.0f, 1.0f, 1.0f, 1.0f);
+
+ return v;
+ }
+
+ void VertexRoutine::postTransform(Registers &r)
+ {
+ int pos = state.positionRegister;
+
+ if(state.postTransform && !state.preTransformed)
+ {
+ Float4 posScale = *Pointer<Float4>(r.data + OFFSET(DrawData,posScale)); // FIXME: Unpack
+
+ r.ox[pos] = r.ox[pos] * posScale.x;
+ r.oy[pos] = r.oy[pos] * posScale.y;
+
+ Float4 posOffset = *Pointer<Float4>(r.data + OFFSET(DrawData,posOffset)); // FIXME: Unpack
+
+ r.ox[pos] = r.ox[pos] + r.ow[pos] * posOffset.x;
+ r.oy[pos] = r.oy[pos] + r.ow[pos] * posOffset.y;
+ }
+ }
+
+ void VertexRoutine::writeCache(Pointer<Byte> &cacheLine, Registers &r)
+ {
+ Color4f v;
+
+ for(int i = 0; i < 12; i++)
+ {
+ if(state.output[i].write)
+ {
+ v.x = r.ox[i];
+ v.y = r.oy[i];
+ v.z = r.oz[i];
+ v.w = r.ow[i];
+
+ if(state.output[i].xClamp)
+ {
+ v.x = Max(v.x, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ v.x = Min(v.x, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ }
+
+ if(state.output[i].yClamp)
+ {
+ v.y = Max(v.y, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ v.y = Min(v.y, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ }
+
+ if(state.output[i].zClamp)
+ {
+ v.z = Max(v.z, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ v.z = Min(v.z, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ }
+
+ if(state.output[i].wClamp)
+ {
+ v.w = Max(v.w, Float4(0.0f, 0.0f, 0.0f, 0.0f));
+ v.w = Min(v.w, Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ }
+
+ if(state.output[i].write == 0x01)
+ {
+ *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 0) = v.x.x;
+ *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 1) = v.x.y;
+ *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 2) = v.x.z;
+ *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 3) = v.x.w;
+ }
+ else
+ {
+ if(state.output[i].write == 0x02)
+ {
+ transpose2x4(v.x, v.y, v.z, v.w);
+ }
+ else
+ {
+ transpose4x4(v.x, v.y, v.z, v.w);
+ }
+
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 0, 16) = v.x;
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 1, 16) = v.y;
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 2, 16) = v.z;
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 3, 16) = v.w;
+ }
+ }
+ }
+
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 0) = (r.clipFlags >> 0) & 0x0000000FF; // FIXME: unsigned char Vertex::clipFlags
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 1) = (r.clipFlags >> 8) & 0x0000000FF;
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 2) = (r.clipFlags >> 16) & 0x0000000FF;
+ *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 3) = (r.clipFlags >> 24) & 0x0000000FF;
+
+ int pos = state.positionRegister;
+
+ v.x = r.ox[pos];
+ v.y = r.oy[pos];
+ v.z = r.oz[pos];
+ v.w = r.ow[pos];
+
+ Float4 w = As<Float4>(As<Int4>(v.w) | (As<Int4>(CmpEQ(v.w, Float4(0, 0, 0, 0))) & As<Int4>(Float4(1, 1, 1, 1))));
+ Float4 rhw = Float4(1.0f) / w;
+
+ v.x = As<Float4>(RoundInt(*Pointer<Float4>(r.data + OFFSET(DrawData,LLLLx16)) + v.x * rhw * *Pointer<Float4>(r.data + OFFSET(DrawData,WWWWx16))));
+ v.y = As<Float4>(RoundInt(*Pointer<Float4>(r.data + OFFSET(DrawData,TTTTx16)) + v.y * rhw * *Pointer<Float4>(r.data + OFFSET(DrawData,HHHHx16))));
+ v.z = v.z * rhw;
+ v.w = rhw;
+
+ transpose4x4(v.x, v.y, v.z, v.w);
+
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 0, 16) = v.x;
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 1, 16) = v.y;
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 2, 16) = v.z;
+ *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 3, 16) = v.w;
+ }
+
+ void VertexRoutine::writeVertex(Pointer<Byte> &vertex, Pointer<Byte> &cache)
+ {
+ for(int i = 0; i < 12; i++)
+ {
+ if(state.output[i].write)
+ {
+ *Pointer<Float4>(vertex + OFFSET(Vertex,v[i])) = *Pointer<Float4>(cache + OFFSET(Vertex,v[i]));
+ }
+ }
+
+ *Pointer<Int>(vertex + OFFSET(Vertex,clipFlags)) = *Pointer<Int>(cache + OFFSET(Vertex,clipFlags));
+ *Pointer<Float4>(vertex + OFFSET(Vertex,X)) = *Pointer<Float4>(cache + OFFSET(Vertex,X));
+ }
+}
diff --git a/src/Shader/VertexRoutine.hpp b/src/Shader/VertexRoutine.hpp
new file mode 100644
index 0000000..9c21662
--- /dev/null
+++ b/src/Shader/VertexRoutine.hpp
@@ -0,0 +1,88 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_VertexRoutine_hpp
+#define sw_VertexRoutine_hpp
+
+#include "Renderer/Color.hpp"
+#include "Renderer/VertexProcessor.hpp"
+#include "Reactor/Reactor.hpp"
+
+namespace sw
+{
+ class VertexRoutine
+ {
+ protected:
+ struct Registers
+ {
+ Registers() : callStack(4), aL(4), increment(4), iteration(4), enableStack(1 + 24), ox(12), oy(12), oz(12), ow(12)
+ {
+ loopDepth = -1;
+ enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+ }
+
+ Pointer<Byte> data;
+ Pointer<Byte> constants;
+
+ Array<Float4> ox;
+ Array<Float4> oy;
+ Array<Float4> oz;
+ Array<Float4> ow;
+
+ Int clipFlags;
+
+ Color4f v[16];
+ Color4f r[32];
+ Color4f a0;
+ Array<Int> aL;
+ Color4f p0;
+
+ Array<Int> increment;
+ Array<Int> iteration;
+
+ Int loopDepth;
+ Int stackIndex; // FIXME: Inc/decrement callStack
+ Array<UInt> callStack;
+
+ Int enableIndex;
+ Array<Int4> enableStack;
+ Int4 enableBreak;
+ };
+
+ public:
+ VertexRoutine(const VertexProcessor::State &state);
+
+ virtual ~VertexRoutine();
+
+ void generate();
+ Routine *getRoutine();
+
+ protected:
+ const VertexProcessor::State &state;
+
+ private:
+ virtual void pipeline(Registers &r) = 0;
+
+ typedef VertexProcessor::State::Input Stream;
+
+ Color4f readStream(Registers &r, Pointer<Byte> &buffer, UInt &stride, const Stream &stream, const UInt &index);
+ void readInput(Registers &r, UInt &index);
+ void computeClipFlags(Registers &r);
+ void postTransform(Registers &r);
+ void writeCache(Pointer<Byte> &cacheLine, Registers &r);
+ void writeVertex(Pointer<Byte> &vertex, Pointer<Byte> &cacheLine);
+
+ Routine *routine;
+ };
+}
+
+#endif // sw_VertexRoutine_hpp
diff --git a/src/Shader/VertexShader.cpp b/src/Shader/VertexShader.cpp
new file mode 100644
index 0000000..c958820
--- /dev/null
+++ b/src/Shader/VertexShader.cpp
@@ -0,0 +1,266 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "VertexShader.hpp"
+
+#include "Vertex.hpp"
+#include "Debug.hpp"
+
+namespace sw
+{
+ VertexShader::VertexShader(const unsigned long *token) : Shader(token)
+ {
+ parse(token);
+ }
+
+ VertexShader::~VertexShader()
+ {
+ }
+
+ void VertexShader::parse(const unsigned long *token)
+ {
+ minorVersion = (unsigned char)(token[0] & 0x000000FF);
+ majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
+ shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);
+
+ length = validate(token);
+ ASSERT(length != 0);
+
+ instruction = new Shader::Instruction*[length];
+
+ for(int i = 0; i < length; i++)
+ {
+ while((*token & 0x0000FFFF) == 0x0000FFFE) // Comment token
+ {
+ int length = (*token & 0x7FFF0000) >> 16;
+
+ token += length + 1;
+ }
+
+ int tokenCount = size(*token);
+
+ instruction[i] = new Instruction(token, tokenCount, majorVersion);
+
+ token += 1 + tokenCount;
+ }
+
+ analyzeInput();
+ analyzeOutput();
+ analyzeDirtyConstants();
+ analyzeTexldl();
+ analyzeDynamicBranching();
+ analyzeSamplers();
+ }
+
+ int VertexShader::validate(const unsigned long *const token)
+ {
+ if(!token)
+ {
+ return 0;
+ }
+
+ unsigned short version = (unsigned short)(token[0] & 0x0000FFFF);
+ unsigned char minorVersion = (unsigned char)(token[0] & 0x000000FF);
+ unsigned char majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
+ ShaderType shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);
+
+ if(shaderType != SHADER_VERTEX || majorVersion > 3)
+ {
+ return 0;
+ }
+
+ int instructionCount = 1;
+
+ for(int i = 0; token[i] != 0x0000FFFF; i++)
+ {
+ if((token[i] & 0x0000FFFF) == 0x0000FFFE) // Comment token
+ {
+ int length = (token[i] & 0x7FFF0000) >> 16;
+
+ i += length;
+ }
+ else
+ {
+ ShaderOpcode opcode = (ShaderOpcode)(token[i] & 0x0000FFFF);
+
+ switch(opcode)
+ {
+ case ShaderOperation::OPCODE_TEXCOORD:
+ case ShaderOperation::OPCODE_TEXKILL:
+ case ShaderOperation::OPCODE_TEX:
+ case ShaderOperation::OPCODE_TEXBEM:
+ case ShaderOperation::OPCODE_TEXBEML:
+ case ShaderOperation::OPCODE_TEXREG2AR:
+ case ShaderOperation::OPCODE_TEXREG2GB:
+ case ShaderOperation::OPCODE_TEXM3X2PAD:
+ case ShaderOperation::OPCODE_TEXM3X2TEX:
+ case ShaderOperation::OPCODE_TEXM3X3PAD:
+ case ShaderOperation::OPCODE_TEXM3X3TEX:
+ case ShaderOperation::OPCODE_RESERVED0:
+ case ShaderOperation::OPCODE_TEXM3X3SPEC:
+ case ShaderOperation::OPCODE_TEXM3X3VSPEC:
+ case ShaderOperation::OPCODE_TEXREG2RGB:
+ case ShaderOperation::OPCODE_TEXDP3TEX:
+ case ShaderOperation::OPCODE_TEXM3X2DEPTH:
+ case ShaderOperation::OPCODE_TEXDP3:
+ case ShaderOperation::OPCODE_TEXM3X3:
+ case ShaderOperation::OPCODE_TEXDEPTH:
+ case ShaderOperation::OPCODE_CMP:
+ case ShaderOperation::OPCODE_BEM:
+ case ShaderOperation::OPCODE_DP2ADD:
+ case ShaderOperation::OPCODE_DSX:
+ case ShaderOperation::OPCODE_DSY:
+ case ShaderOperation::OPCODE_TEXLDD:
+ return 0; // Unsupported operation
+ default:
+ instructionCount++;
+ break;
+ }
+
+ i += size(token[i], version);
+ }
+ }
+
+ return instructionCount;
+ }
+
+ bool VertexShader::containsTexldl() const
+ {
+ return texldl;
+ }
+
+ void VertexShader::analyzeInput()
+ {
+ for(int i = 0; i < 16; i++)
+ {
+ input[i] = Semantic(-1, -1);
+ }
+
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getOpcode() == ShaderOperation::OPCODE_DCL &&
+ instruction[i]->getDestinationParameter().type == ShaderParameter::PARAMETER_INPUT)
+ {
+ int index = instruction[i]->getDestinationParameter().index;
+
+ input[index] = Semantic(instruction[i]->getUsage(), instruction[i]->getUsageIndex());
+ }
+ }
+ }
+
+ void VertexShader::analyzeOutput()
+ {
+ positionRegister = Pos;
+ pointSizeRegister = -1; // No vertex point size
+
+ if(version < 0x0300)
+ {
+ output[Pos][0] = Semantic(ShaderOperation::USAGE_POSITION, 0);
+ output[Pos][1] = Semantic(ShaderOperation::USAGE_POSITION, 0);
+ output[Pos][2] = Semantic(ShaderOperation::USAGE_POSITION, 0);
+ output[Pos][3] = Semantic(ShaderOperation::USAGE_POSITION, 0);
+
+ for(int i = 0; i < length; i++)
+ {
+ const Instruction::DestinationParameter &dst = instruction[i]->getDestinationParameter();
+
+ switch(dst.type)
+ {
+ case ShaderParameter::PARAMETER_RASTOUT:
+ switch(dst.index)
+ {
+ case 0:
+ // Position already assumed written
+ break;
+ case 1:
+ output[Fog][0] = Semantic(ShaderOperation::USAGE_FOG, 0);
+ break;
+ case 2:
+ output[Pts][1] = Semantic(ShaderOperation::USAGE_PSIZE, 0);
+ pointSizeRegister = Pts;
+ break;
+ default: ASSERT(false);
+ }
+ break;
+ case ShaderParameter::PARAMETER_ATTROUT:
+ if(dst.index == 0)
+ {
+ if(dst.x) output[D0][0] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+ if(dst.y) output[D0][1] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+ if(dst.z) output[D0][2] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+ if(dst.w) output[D0][3] = Semantic(ShaderOperation::USAGE_COLOR, 0);
+ }
+ else if(dst.index == 1)
+ {
+ if(dst.x) output[D1][0] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+ if(dst.y) output[D1][1] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+ if(dst.z) output[D1][2] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+ if(dst.w) output[D1][3] = Semantic(ShaderOperation::USAGE_COLOR, 1);
+ }
+ else ASSERT(false);
+ break;
+ case ShaderParameter::PARAMETER_TEXCRDOUT:
+ if(dst.x) output[T0 + dst.index][0] = Semantic(ShaderOperation::USAGE_TEXCOORD, dst.index);
+ if(dst.y) output[T0 + dst.index][1] = Semantic(ShaderOperation::USAGE_TEXCOORD, dst.index);
+ if(dst.z) output[T0 + dst.index][2] = Semantic(ShaderOperation::USAGE_TEXCOORD, dst.index);
+ if(dst.w) output[T0 + dst.index][3] = Semantic(ShaderOperation::USAGE_TEXCOORD, dst.index);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ else // Shader Model 3.0 input declaration
+ {
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getOpcode() == ShaderOperation::OPCODE_DCL &&
+ instruction[i]->getDestinationParameter().type == ShaderParameter::PARAMETER_OUTPUT)
+ {
+ unsigned char usage = instruction[i]->getUsage();
+ unsigned char usageIndex = instruction[i]->getUsageIndex();
+
+ const Instruction::DestinationParameter &dst = instruction[i]->getDestinationParameter();
+
+ if(dst.x) output[dst.index][0] = Semantic(usage, usageIndex);
+ if(dst.y) output[dst.index][1] = Semantic(usage, usageIndex);
+ if(dst.z) output[dst.index][2] = Semantic(usage, usageIndex);
+ if(dst.w) output[dst.index][3] = Semantic(usage, usageIndex);
+
+ if(usage == ShaderOperation::USAGE_POSITION && usageIndex == 0)
+ {
+ positionRegister = dst.index;
+ }
+
+ if(usage == ShaderOperation::USAGE_PSIZE && usageIndex == 0)
+ {
+ pointSizeRegister = dst.index;
+ }
+ }
+ }
+ }
+ }
+
+ void VertexShader::analyzeTexldl()
+ {
+ texldl = false;
+
+ for(int i = 0; i < length; i++)
+ {
+ if(instruction[i]->getOpcode() == Instruction::Operation::OPCODE_TEXLDL)
+ {
+ texldl = true;
+
+ break;
+ }
+ }
+ }
+}
diff --git a/src/Shader/VertexShader.hpp b/src/Shader/VertexShader.hpp
new file mode 100644
index 0000000..1200b20
--- /dev/null
+++ b/src/Shader/VertexShader.hpp
@@ -0,0 +1,48 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2011 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_VertexShader_hpp
+#define sw_VertexShader_hpp
+
+#include "Shader.hpp"
+
+namespace sw
+{
+ class VertexShader : public Shader
+ {
+ public:
+ VertexShader(const unsigned long *token);
+
+ virtual ~VertexShader();
+
+ static int validate(const unsigned long *const token); // Returns number of instructions if valid
+ bool containsTexldl() const;
+
+ int positionRegister; // FIXME: Private
+ int pointSizeRegister; // FIXME: Private
+
+ Semantic input[16]; // FIXME: Private
+ Semantic output[12][4]; // FIXME: Private
+
+ private:
+ void parse(const unsigned long *token);
+
+ void analyzeInput();
+ void analyzeOutput();
+ void analyzeTexldl();
+
+ bool texldl;
+ };
+
+ typedef VertexShader::Instruction VertexShaderInstruction;
+}
+
+#endif // sw_VertexShader_hpp
