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