void GSDrawScanlineCodeGenerator::TestDestAlpha()
{
if(!m_sel.date || m_sel.fpsm != 0 && m_sel.fpsm != 2)
{
return;
}
// test |= ((fd [<< 16]) ^ m_env.datm).sra32(31);
movdqa(xmm1, xmm2);
if(m_sel.datm)
{
if(m_sel.fpsm == 2)
{
pxor(xmm0, xmm0);
psrld(xmm1, 15);
pcmpeqd(xmm1, xmm0);
}
else
{
pcmpeqd(xmm0, xmm0);
pxor(xmm1, xmm0);
psrad(xmm1, 31);
}
}
else
{
if(m_sel.fpsm == 2)
{
pslld(xmm1, 16);
}
psrad(xmm1, 31);
}
por(xmm7, xmm1);
alltrue();
}
int main()
{
int rval;
mmx_t ma;
mmx_t mb;
movq_r2r(mm0, mm1);
rval = mmx_ok();
/* Announce return value of mmx_ok() */
// printf("Value returned from init was %x.", rval);
// printf(" (Indicates MMX %s available)\n\n",(rval)? "is" : "not");
// fflush(stdout); fflush(stderr);
// if(rval)
{
/* PADD *****************************************************/
ma.q = 0x1111111180000000LL;
mb.q = 0x7fffffff00000001LL;
paddd(ma, mb);
fprintf(stdout, "paddd: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddd: mb.q is 9111111080000001\n");
fflush(stdout); fflush(stderr);
ma.q = 0x0001000100010001LL;
mb.q = 0x80007fffffff0001LL;
paddw(ma, mb);
fprintf(stdout, "paddw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddw: mb.q is 8001800000000002\n");
fflush(stdout); fflush(stderr);
ma.q = 0x80007fffffff0001LL;
mb.q = 0x0001000100010000LL;
paddw(ma, mb);
fprintf(stdout, "paddw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddw: mb.q is 8001800000000001\n");
fflush(stdout); fflush(stderr);
ma.q = 0x01010101807fff01LL;
mb.q = 0x807fff0101010101LL;
paddb(ma, mb);
fprintf(stdout, "paddb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddb: mb.q is 8180000281800002\n");
fflush(stdout); fflush(stderr);
/* PADDS ****************************************************/
ma.q = 0x0001000100010001LL;
mb.q = 0x80007fffffff0001LL;
paddsw(ma, mb);
fprintf(stdout, "paddsw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddsw: mb.q is 80017fff00000002\n");
ma.q = 0x80007fffffff0001LL;
mb.q = 0x0001000100010000LL;
paddsw(ma, mb);
fprintf(stdout, "paddsw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddsw: mb.q is 80017fff00000001\n");
ma.q = 0x01010101807fff01LL;
mb.q = 0x807fff0101010101LL;
paddsb(ma, mb);
fprintf(stdout, "paddsb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddsb: mb.q is 817f0002817f0002\n");
fflush(stdout); fflush(stderr);
/* PADDUS ***************************************************/
ma.q = 0x0001000100010001LL;
mb.q = 0x80007fffffff0001LL;
paddusw(ma, mb);
fprintf(stdout, "paddusw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddusw: mb.q is 80018000ffff0002\n");
fflush(stdout); fflush(stderr);
ma.q = 0x80007fffffff0001LL;
mb.q = 0x0001000100010000LL;
paddusw(ma, mb);
fprintf(stdout, "paddusw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddusw: mb.q is 80018000ffff0001\n");
fflush(stdout); fflush(stderr);
ma.q = 0x01010101807fff01LL;
mb.q = 0x807fff0101010101LL;
paddusb(ma, mb);
fprintf(stdout, "paddusb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "paddusb: mb.q is 8180ff028180ff02\n");
fflush(stdout); fflush(stderr);
/* PSUB *****************************************************/
ma.q = 0x7fffffff00000001LL;
mb.q = 0x1111111180000000LL;
psubd(ma, mb);
fprintf(stdout, "psubd: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubd: mb.q is 911111127fffffff\n");
fflush(stdout); fflush(stderr);
ma.q = 0x80007fffffff0001LL;
mb.q = 0x0001000100010001LL;
psubw(ma, mb);
fprintf(stdout, "psubw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubw: mb.q is 8001800200020000\n");
fflush(stdout); fflush(stderr);
ma.q = 0x0001000100010000LL;
mb.q = 0x80007fffffff0001LL;
psubw(ma, mb);
fprintf(stdout, "psubw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubw: mb.q is 7fff7ffefffe0001\n");
fflush(stdout); fflush(stderr);
ma.q = 0x807fff0101010101LL;
mb.q = 0x01010101807fff01LL;
psubb(ma, mb);
fprintf(stdout, "psubb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubb: mb.q is 818202007f7efe00\n");
fflush(stdout); fflush(stderr);
/* PSUBS ****************************************************/
ma.q = 0x80007fffffff0001LL;
mb.q = 0x0001000100010001LL;
psubsw(ma, mb);
fprintf(stdout, "psubsw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubsw: mb.q is 7fff800200020000\n");
fflush(stdout); fflush(stderr);
ma.q = 0x0001000100010000LL;
mb.q = 0x80007fffffff0001LL;
psubsw(ma, mb);
fprintf(stdout, "psubsw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubsw: mb.q is 80007ffefffe0001\n");
fflush(stdout); fflush(stderr);
ma.q = 0x807fff0101010101LL;
mb.q = 0x01010101807fff01LL;
psubsb(ma, mb);
fprintf(stdout, "psubsb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubsb: mb.q is 7f820200807efe00\n");
fflush(stdout); fflush(stderr);
/* PSUBUS ***************************************************/
ma.q = 0x80007fffffff0001LL;
mb.q = 0x0001000100010001LL;
psubusw(ma, mb);
fprintf(stdout, "psubusw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubusw: mb.q is 0000000000000000\n");
fflush(stdout); fflush(stderr);
ma.q = 0x0001000100010000LL;
mb.q = 0x80007fffffff0001LL;
psubusw(ma, mb);
fprintf(stdout, "psubusw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubusw: mb.q is 7fff7ffefffe0001\n");
fflush(stdout); fflush(stderr);
ma.q = 0x807fff0101010101LL;
mb.q = 0x01010101807fff01LL;
psubusb(ma, mb);
fprintf(stdout, "psubusb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psubusb: mb.q is 000000007f7efe00\n");
fflush(stdout); fflush(stderr);
/* PMUL *****************************************************/
ma.q = 0x8000ffff00ff0000LL;
mb.q = 0x0200ffff00ffffffLL;
pmulhw(ma, mb);
fprintf(stdout, "pmulhw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pmulhw: mb.q is ff00000000000000\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0200ffff00ffffffLL;
pmullw(ma, mb);
fprintf(stdout, "pmullw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pmullw: mb.q is 00000001fe010000\n");
fflush(stdout); fflush(stderr);
/* PMADD ****************************************************/
ma.q = 0x8000345680007f34LL;
mb.q = 0x93234a27ffff1707LL;
pmaddwd(ma, mb);
fprintf(stdout, "pmaddwd: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pmaddwd: mb.q is 4597551a0b71a66c\n");
fflush(stdout); fflush(stderr);
/* PCMPEQ ***************************************************/
ma.q = 0x800034568f237f34LL;
mb.q = 0x93009a568f237f34LL;
pcmpeqd(ma, mb);
fprintf(stdout, "pcmpeqd: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pcmpeqd: mb.q is 00000000ffffffff\n");
fflush(stdout); fflush(stderr);
mb.q = 0x93009a568f237f34LL;
pcmpeqw(ma, mb);
fprintf(stdout, "pcmpeqw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pcmpeqw: mb.q is 00000000ffffffff\n");
fflush(stdout); fflush(stderr);
mb.q = 0x93009a568f237f34LL;
pcmpeqb(ma, mb);
fprintf(stdout, "pcmpeqb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pcmpeqb: mb.q is 00ff00ffffffffff\n");
fflush(stdout); fflush(stderr);
/* PCMPGT ***************************************************/
ma.q = 0x666688884477aaffLL;
mb.q = 0x1234567890abcdefLL;
pcmpgtd(ma, mb);
fprintf(stdout, "pcmpgtd: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pcmpgtd: mb.q is 0000000000000000\n");
fflush(stdout); fflush(stderr);
mb.q = 0x1234567890abcdefLL;
pcmpgtw(ma, mb);
fprintf(stdout, "pcmpgtw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pcmpgtw: mb.q is 0000ffff0000ffff\n");
fflush(stdout); fflush(stderr);
mb.q = 0x1234567890abcdefLL;
pcmpgtb(ma, mb);
fprintf(stdout, "pcmpgtb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pcmpgtb: mb.q is 0000ffff0000ff00\n");
fflush(stdout); fflush(stderr);
/* PACKSS ***************************************************/
ma.q = 0x00012222000abbbbLL;
mb.q = 0x0000888800003333LL;
packssdw(ma, mb);
fprintf(stdout, "packssdw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "packssdw: mb.q is 7fff7fff7fff3333\n");
fflush(stdout); fflush(stderr);
ma.q = 0x00aa00dd01009999LL;
mb.q = 0x0011002200330044LL;
packsswb(ma, mb);
fprintf(stdout, "packsswb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "packsswb: mb.q is 7f7f7f8011223344\n");
fflush(stdout); fflush(stderr);
/* PACKUS ***************************************************/
ma.q = 0x00aa00dd01009999LL;
mb.q = 0x0011002200330044LL;
packuswb(ma, mb);
fprintf(stdout, "packuswb: mb.q is %016llx\n", mb.q);
fprintf(stderr, "packuswb: mb.q is aaddff0011223344\n");
fflush(stdout); fflush(stderr);
/* PUNPCKH **************************************************/
ma.q = 0x090a0b0c0d0e0f00LL;
mb.q = 0x0102030405060708LL;
punpckhdq(ma, mb);
fprintf(stdout, "punpckhdq: mb.q is %016llx\n", mb.q);
fprintf(stderr, "punpckhdq: mb.q is 090a0b0c01020304\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0102030405060708LL;
punpckhwd(ma, mb);
fprintf(stdout, "punpckhwd: mb.q is %016llx\n", mb.q);
fprintf(stderr, "punpckhwd: mb.q is 090a01020b0c0304\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0102030405060708LL;
punpckhbw(ma, mb);
fprintf(stdout, "punpckhbw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "punpckhbw: mb.q is 09010a020b030c04\n");
fflush(stdout); fflush(stderr);
/* PUNPCKL **************************************************/
ma.q = 0x090a0b0c0d0e0f00LL;
mb.q = 0x0102030405060708LL;
punpckldq(ma, mb);
fprintf(stdout, "punpckldq: mb.q is %016llx\n", mb.q);
fprintf(stderr, "punpckldq: mb.q is 0d0e0f0005060708\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0102030405060708LL;
punpcklwd(ma, mb);
fprintf(stdout, "punpcklwd: mb.q is %016llx\n", mb.q);
fprintf(stderr, "punpcklwd: mb.q is 0d0e05060f000708\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0102030405060708LL;
punpcklbw(ma, mb);
fprintf(stdout, "punpcklbw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "punpcklbw: mb.q is 0d050e060f070008\n");
fflush(stdout); fflush(stderr);
/* PAND, PANDN, POR, PXOR ***********************************/
ma.q = 0x5555555555555555LL;
mb.q = 0x3333333333333333LL;
pand(ma, mb);
fprintf(stdout, "pand: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pand: mb.q is 1111111111111111\n");
fflush(stdout); fflush(stderr);
mb.q = 0x3333333333333333LL;
pandn(ma, mb);
fprintf(stdout, "pandn: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pandn: mb.q is 4444444444444444\n");
fflush(stdout); fflush(stderr);
mb.q = 0x3333333333333333LL;
por(ma, mb);
fprintf(stdout, "por: mb.q is %016llx\n", mb.q);
fprintf(stderr, "por: mb.q is 7777777777777777\n");
fflush(stdout); fflush(stderr);
mb.q = 0x3333333333333333LL;
pxor(ma, mb);
fprintf(stdout, "pxor: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pxor: mb.q is 6666666666666666\n");
fflush(stdout); fflush(stderr);
/* PSLL *****************************************************/
ma.q = 0x0000000000000018LL;
mb.q = 0x0123456789abcdefLL;
psllq(ma, mb);
fprintf(stdout, "psllq: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psllq: mb.q is 6789abcdef000000\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0123456789abcdefLL;
pslld(ma, mb);
fprintf(stdout, "pslld: mb.q is %016llx\n", mb.q);
fprintf(stderr, "pslld: mb.q is 67000000ef000000\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0123456789abcdefLL;
psllw(ma, mb);
fprintf(stdout, "psllw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psllw: mb.q is 0000000000000000\n");
fflush(stdout); fflush(stderr);
/* PSRL *****************************************************/
ma.q = 0x0000000000000018LL;
mb.q = 0x0123456789abcdefLL;
psrlq(ma, mb);
fprintf(stdout, "psrlq: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psrlq: mb.q is 0000000123456789\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0123456789abcdefLL;
psrld(ma, mb);
fprintf(stdout, "psrld: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psrld: mb.q is 0000000100000089\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0123456789abcdefLL;
psrlw(ma, mb);
fprintf(stdout, "psrlw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psrlw: mb.q is 0000000000000000\n");
fflush(stdout); fflush(stderr);
/* PSRA *****************************************************/
ma.q = 0x0000000000000018LL;
mb.q = 0x0123456789abcdefLL;
psrad(ma, mb);
fprintf(stdout, "psrad: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psrad: mb.q is 00000001ffffff89\n");
fflush(stdout); fflush(stderr);
mb.q = 0x0123456789abcdefLL;
psraw(ma, mb);
fprintf(stdout, "psraw: mb.q is %016llx\n", mb.q);
fprintf(stderr, "psraw: mb.q is 00000000ffffffff\n");
fflush(stdout); fflush(stderr);
/* Exit MXX *************************************************/
emms();
}
/* Clean-up and exit nicely */
exit(0);
}
void GSSetupPrimCodeGenerator::Depth()
{
if(!m_en.z && !m_en.f)
{
return;
}
if(!m_env.sel.sprite)
{
// GSVector4 t = dscan.p;
movaps(xmm0, xmmword[edx + 16]);
if(m_en.f)
{
// GSVector4 df = p.wwww();
movaps(xmm1, xmm0);
shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
// m_env.d4.f = GSVector4i(df * 4.0f).xxzzlh();
movaps(xmm2, xmm1);
mulps(xmm2, xmm3);
cvttps2dq(xmm2, xmm2);
pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
movdqa(xmmword[&m_env.d4.f], xmm2);
for(int i = 0; i < 4; i++)
{
// m_env.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
movaps(xmm2, xmm1);
mulps(xmm2, Xmm(4 + i));
cvttps2dq(xmm2, xmm2);
pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
movdqa(xmmword[&m_env.d[i].f], xmm2);
}
}
if(m_en.z)
{
// GSVector4 dz = p.zzzz();
shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
// m_env.d4.z = dz * 4.0f;
movaps(xmm1, xmm0);
mulps(xmm1, xmm3);
movdqa(xmmword[&m_env.d4.z], xmm1);
for(int i = 0; i < 4; i++)
{
// m_env.d[i].z = dz * m_shift[i];
movaps(xmm1, xmm0);
mulps(xmm1, Xmm(4 + i));
movdqa(xmmword[&m_env.d[i].z], xmm1);
}
}
}
else
{
// GSVector4 p = vertices[0].p;
movaps(xmm0, xmmword[ecx + 16]);
if(m_en.f)
{
// m_env.p.f = GSVector4i(p).zzzzh().zzzz();
movaps(xmm1, xmm0);
cvttps2dq(xmm1, xmm1);
pshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
pshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
movdqa(xmmword[&m_env.p.f], xmm1);
}
if(m_en.z)
{
// GSVector4 z = p.zzzz();
shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
if(m_env.sel.zoverflow)
{
// m_env.p.z = (GSVector4i(z * 0.5f) << 1) | (GSVector4i(z) & GSVector4i::x00000001());
static const float half = 0.5f;
movss(xmm1, dword[&half]);
shufps(xmm1, xmm1, _MM_SHUFFLE(0, 0, 0, 0));
mulps(xmm1, xmm0);
cvttps2dq(xmm1, xmm1);
pslld(xmm1, 1);
cvttps2dq(xmm0, xmm0);
pcmpeqd(xmm2, xmm2);
psrld(xmm2, 31);
pand(xmm0, xmm2);
por(xmm0, xmm1);
}
else
{
// m_env.p.z = GSVector4i(z);
cvttps2dq(xmm0, xmm0);
}
movdqa(xmmword[&m_env.p.z], xmm0);
}
}
}
void GSDrawScanlineCodeGenerator::SampleTexture()
{
if(!m_sel.fb || m_sel.tfx == TFX_NONE)
{
return;
}
mov(ebx, dword[&m_env.tex]);
// ebx = tex
if(!m_sel.fst)
{
// TODO: move these into Init/Step too?
cvttps2dq(xmm2, xmm2);
cvttps2dq(xmm3, xmm3);
if(m_sel.ltf)
{
// u -= 0x8000;
// v -= 0x8000;
mov(eax, 0x8000);
movd(xmm4, eax);
pshufd(xmm4, xmm4, _MM_SHUFFLE(0, 0, 0, 0));
psubd(xmm2, xmm4);
psubd(xmm3, xmm4);
}
}
// xmm2 = u
// xmm3 = v
if(m_sel.ltf)
{
// GSVector4i uf = u.xxzzlh().srl16(1);
movdqa(xmm0, xmm2);
pshuflw(xmm0, xmm0, _MM_SHUFFLE(2, 2, 0, 0));
pshufhw(xmm0, xmm0, _MM_SHUFFLE(2, 2, 0, 0));
psrlw(xmm0, 1);
movdqa(xmmword[&m_env.temp.uf], xmm0);
if(!m_sel.sprite)
{
// GSVector4i vf = v.xxzzlh().srl16(1);
movdqa(xmm1, xmm3);
pshuflw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 0, 0));
pshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 0, 0));
psrlw(xmm1, 1);
movdqa(xmmword[&m_env.temp.vf], xmm1);
}
}
// GSVector4i uv0 = u.sra32(16).ps32(v.sra32(16));
psrad(xmm2, 16);
psrad(xmm3, 16);
packssdw(xmm2, xmm3);
if(m_sel.ltf)
{
// GSVector4i uv1 = uv0.add16(GSVector4i::x0001());
movdqa(xmm3, xmm2);
pcmpeqd(xmm1, xmm1);
psrlw(xmm1, 15);
paddw(xmm3, xmm1);
// uv0 = Wrap(uv0);
// uv1 = Wrap(uv1);
Wrap(xmm2, xmm3);
}
else
{
// uv0 = Wrap(uv0);
Wrap(xmm2);
}
// xmm2 = uv0
// xmm3 = uv1 (ltf)
// xmm0, xmm1, xmm4, xmm5, xmm6 = free
// xmm7 = used
// GSVector4i y0 = uv0.uph16() << tw;
// GSVector4i x0 = uv0.upl16();
pxor(xmm0, xmm0);
movd(xmm1, ptr[&m_env.tw]);
movdqa(xmm4, xmm2);
punpckhwd(xmm2, xmm0);
punpcklwd(xmm4, xmm0);
pslld(xmm2, xmm1);
// xmm0 = 0
// xmm1 = tw
// xmm2 = y0
// xmm3 = uv1 (ltf)
// xmm4 = x0
// xmm5, xmm6 = free
// xmm7 = used
if(m_sel.ltf)
{
// GSVector4i y1 = uv1.uph16() << tw;
// GSVector4i x1 = uv1.upl16();
movdqa(xmm6, xmm3);
punpckhwd(xmm3, xmm0);
punpcklwd(xmm6, xmm0);
pslld(xmm3, xmm1);
// xmm2 = y0
// xmm3 = y1
// xmm4 = x0
// xmm6 = x1
// xmm0, xmm5, xmm6 = free
// xmm7 = used
// GSVector4i addr00 = y0 + x0;
// GSVector4i addr01 = y0 + x1;
// GSVector4i addr10 = y1 + x0;
// GSVector4i addr11 = y1 + x1;
movdqa(xmm5, xmm2);
paddd(xmm5, xmm4);
paddd(xmm2, xmm6);
movdqa(xmm0, xmm3);
paddd(xmm0, xmm4);
paddd(xmm3, xmm6);
// xmm5 = addr00
// xmm2 = addr01
// xmm0 = addr10
// xmm3 = addr11
// xmm1, xmm4, xmm6 = free
// xmm7 = used
// c00 = addr00.gather32_32((const uint32/uint8*)tex[, clut]);
// c01 = addr01.gather32_32((const uint32/uint8*)tex[, clut]);
// c10 = addr10.gather32_32((const uint32/uint8*)tex[, clut]);
// c11 = addr11.gather32_32((const uint32/uint8*)tex[, clut]);
ReadTexel(xmm6, xmm5, xmm1, xmm4);
// xmm2, xmm5, xmm1 = free
ReadTexel(xmm4, xmm2, xmm5, xmm1);
// xmm0, xmm2, xmm5 = free
ReadTexel(xmm1, xmm0, xmm2, xmm5);
// xmm3, xmm0, xmm2 = free
ReadTexel(xmm5, xmm3, xmm0, xmm2);
// xmm6 = c00
// xmm4 = c01
// xmm1 = c10
// xmm5 = c11
// xmm0, xmm2, xmm3 = free
// xmm7 = used
movdqa(xmm0, xmmword[&m_env.temp.uf]);
// GSVector4i rb00 = c00 & mask;
// GSVector4i ga00 = (c00 >> 8) & mask;
movdqa(xmm2, xmm6);
psllw(xmm2, 8);
psrlw(xmm2, 8);
psrlw(xmm6, 8);
// GSVector4i rb01 = c01 & mask;
// GSVector4i ga01 = (c01 >> 8) & mask;
movdqa(xmm3, xmm4);
psllw(xmm3, 8);
psrlw(xmm3, 8);
psrlw(xmm4, 8);
// xmm0 = uf
// xmm2 = rb00
// xmm3 = rb01
// xmm6 = ga00
// xmm4 = ga01
// xmm1 = c10
// xmm5 = c11
// xmm7 = used
// rb00 = rb00.lerp16<0>(rb01, uf);
// ga00 = ga00.lerp16<0>(ga01, uf);
lerp16<0>(xmm3, xmm2, xmm0);
lerp16<0>(xmm4, xmm6, xmm0);
// xmm0 = uf
// xmm3 = rb00
// xmm4 = ga00
// xmm1 = c10
// xmm5 = c11
// xmm2, xmm6 = free
// xmm7 = used
// GSVector4i rb10 = c10 & mask;
// GSVector4i ga10 = (c10 >> 8) & mask;
movdqa(xmm2, xmm1);
psllw(xmm1, 8);
psrlw(xmm1, 8);
psrlw(xmm2, 8);
// GSVector4i rb11 = c11 & mask;
// GSVector4i ga11 = (c11 >> 8) & mask;
movdqa(xmm6, xmm5);
psllw(xmm5, 8);
psrlw(xmm5, 8);
psrlw(xmm6, 8);
// xmm0 = uf
// xmm3 = rb00
// xmm4 = ga00
// xmm1 = rb10
// xmm5 = rb11
// xmm2 = ga10
// xmm6 = ga11
// xmm7 = used
// rb10 = rb10.lerp16<0>(rb11, uf);
// ga10 = ga10.lerp16<0>(ga11, uf);
lerp16<0>(xmm5, xmm1, xmm0);
lerp16<0>(xmm6, xmm2, xmm0);
// xmm3 = rb00
// xmm4 = ga00
// xmm5 = rb10
// xmm6 = ga10
// xmm0, xmm1, xmm2 = free
// xmm7 = used
// rb00 = rb00.lerp16<0>(rb10, vf);
// ga00 = ga00.lerp16<0>(ga10, vf);
movdqa(xmm0, xmmword[&m_env.temp.vf]);
lerp16<0>(xmm5, xmm3, xmm0);
lerp16<0>(xmm6, xmm4, xmm0);
}
else
{
// GSVector4i addr00 = y0 + x0;
paddd(xmm2, xmm4);
// c00 = addr00.gather32_32((const uint32/uint8*)tex[, clut]);
ReadTexel(xmm5, xmm2, xmm0, xmm1);
// GSVector4i mask = GSVector4i::x00ff();
// c[0] = c00 & mask;
// c[1] = (c00 >> 8) & mask;
movdqa(xmm6, xmm5);
psllw(xmm5, 8);
psrlw(xmm5, 8);
psrlw(xmm6, 8);
}
}
void GSDrawScanlineCodeGenerator::TestZ(const Xmm& temp1, const Xmm& temp2)
{
if(!m_sel.zb)
{
return;
}
// int za = fza_base.y + fza_offset->y;
mov(ebp, dword[esi + 4]);
add(ebp, dword[edi + 4]);
// GSVector4i zs = zi;
if(!m_sel.sprite)
{
if(m_sel.zoverflow)
{
// zs = (GSVector4i(z * 0.5f) << 1) | (GSVector4i(z) & GSVector4i::x00000001());
static float half = 0.5f;
movss(temp1, dword[&half]);
shufps(temp1, temp1, _MM_SHUFFLE(0, 0, 0, 0));
mulps(temp1, xmm0);
cvttps2dq(temp1, temp1);
pslld(temp1, 1);
cvttps2dq(xmm0, xmm0);
pcmpeqd(temp2, temp2);
psrld(temp2, 31);
pand(xmm0, temp2);
por(xmm0, temp1);
}
else
{
// zs = GSVector4i(z);
cvttps2dq(xmm0, xmm0);
}
if(m_sel.zwrite)
{
movdqa(xmmword[&m_env.temp.zs], xmm0);
}
}
if(m_sel.ztest)
{
ReadPixel(xmm1, ebp);
if(m_sel.zwrite && m_sel.zpsm < 2)
{
movdqa(xmmword[&m_env.temp.zd], xmm1);
}
// zd &= 0xffffffff >> m_sel.zpsm * 8;
if(m_sel.zpsm)
{
pslld(xmm1, m_sel.zpsm * 8);
psrld(xmm1, m_sel.zpsm * 8);
}
if(m_sel.zoverflow || m_sel.zpsm == 0)
{
// GSVector4i o = GSVector4i::x80000000();
pcmpeqd(xmm4, xmm4);
pslld(xmm4, 31);
// GSVector4i zso = zs - o;
psubd(xmm0, xmm4);
// GSVector4i zdo = zd - o;
psubd(xmm1, xmm4);
}
switch(m_sel.ztst)
{
case ZTST_GEQUAL:
// test |= zso < zdo; // ~(zso >= zdo)
pcmpgtd(xmm1, xmm0);
por(xmm7, xmm1);
break;
case ZTST_GREATER: // TODO: tidus hair and chocobo wings only appear fully when this is tested as ZTST_GEQUAL
// test |= zso <= zdo; // ~(zso > zdo)
pcmpgtd(xmm0, xmm1);
pcmpeqd(xmm4, xmm4);
pxor(xmm0, xmm4);
por(xmm7, xmm0);
break;
}
alltrue();
}
}
void GSDrawScanlineCodeGenerator::WriteFrame(int params)
{
const int _top = params + 4;
if(!m_sel.fwrite)
{
return;
}
if(m_sel.colclamp == 0)
{
// c[0] &= 0x000000ff;
// c[1] &= 0x000000ff;
pcmpeqd(xmm7, xmm7);
psrlw(xmm7, 8);
pand(xmm5, xmm7);
pand(xmm6, xmm7);
}
if(m_sel.fpsm == 2 && m_sel.dthe)
{
mov(eax, dword[esp + _top]);
and(eax, 3);
shl(eax, 5);
paddw(xmm5, xmmword[eax + (size_t)&m_env.dimx[0]]);
paddw(xmm6, xmmword[eax + (size_t)&m_env.dimx[1]]);
}
// GSVector4i fs = c[0].upl16(c[1]).pu16(c[0].uph16(c[1]));
movdqa(xmm7, xmm5);
punpcklwd(xmm5, xmm6);
punpckhwd(xmm7, xmm6);
packuswb(xmm5, xmm7);
if(m_sel.fba && m_sel.fpsm != 1)
{
// fs |= 0x80000000;
pcmpeqd(xmm7, xmm7);
pslld(xmm7, 31);
por(xmm5, xmm7);
}
if(m_sel.fpsm == 2)
{
// GSVector4i rb = fs & 0x00f800f8;
// GSVector4i ga = fs & 0x8000f800;
mov(eax, 0x00f800f8);
movd(xmm6, eax);
pshufd(xmm6, xmm6, _MM_SHUFFLE(0, 0, 0, 0));
mov(eax, 0x8000f800);
movd(xmm7, eax);
pshufd(xmm7, xmm7, _MM_SHUFFLE(0, 0, 0, 0));
movdqa(xmm4, xmm5);
pand(xmm4, xmm6);
pand(xmm5, xmm7);
// fs = (ga >> 16) | (rb >> 9) | (ga >> 6) | (rb >> 3);
movdqa(xmm6, xmm4);
movdqa(xmm7, xmm5);
psrld(xmm4, 3);
psrld(xmm6, 9);
psrld(xmm5, 6);
psrld(xmm7, 16);
por(xmm5, xmm4);
por(xmm7, xmm6);
por(xmm5, xmm7);
}
if(m_sel.rfb)
{
// fs = fs.blend(fd, fm);
blend(xmm5, xmm2, xmm3); // TODO: could be skipped in certain cases, depending on fpsm and fm
}
bool fast = m_sel.rfb && m_sel.fpsm < 2;
WritePixel(xmm5, xmm0, ebx, dl, fast, m_sel.fpsm);
}
void GSDrawScanlineCodeGenerator::AlphaBlend()
{
if(!m_sel.fwrite)
{
return;
}
if(m_sel.abe == 0 && m_sel.aa1 == 0)
{
return;
}
if((m_sel.aba != m_sel.abb) && (m_sel.aba == 1 || m_sel.abb == 1 || m_sel.abc == 1) || m_sel.abd == 1)
{
switch(m_sel.fpsm)
{
case 0:
case 1:
// c[2] = fd & mask;
// c[3] = (fd >> 8) & mask;
movdqa(xmm0, xmm2);
movdqa(xmm1, xmm2);
psllw(xmm0, 8);
psrlw(xmm0, 8);
psrlw(xmm1, 8);
break;
case 2:
// c[2] = ((fd & 0x7c00) << 9) | ((fd & 0x001f) << 3);
// c[3] = ((fd & 0x8000) << 8) | ((fd & 0x03e0) >> 2);
movdqa(xmm0, xmm2);
movdqa(xmm1, xmm2);
movdqa(xmm4, xmm2);
pcmpeqd(xmm7, xmm7);
psrld(xmm7, 27); // 0x0000001f
pand(xmm0, xmm7);
pslld(xmm0, 3);
pslld(xmm7, 10); // 0x00007c00
pand(xmm4, xmm7);
pslld(xmm4, 9);
por(xmm0, xmm4);
movdqa(xmm4, xmm1);
psrld(xmm7, 5); // 0x000003e0
pand(xmm1, xmm7);
psrld(xmm1, 2);
psllw(xmm7, 10); // 0x00008000
pand(xmm4, xmm7);
pslld(xmm4, 8);
por(xmm1, xmm4);
break;
}
}
// xmm5, xmm6 = src rb, ga
// xmm0, xmm1 = dst rb, ga
// xmm2, xmm3 = used
// xmm4, xmm7 = free
if(m_sel.pabe || (m_sel.aba != m_sel.abb) && (m_sel.abb == 0 || m_sel.abd == 0))
{
movdqa(xmm4, xmm5);
}
if(m_sel.aba != m_sel.abb)
{
// rb = c[aba * 2 + 0];
switch(m_sel.aba)
{
case 0:
break;
case 1:
movdqa(xmm5, xmm0);
break;
case 2:
pxor(xmm5, xmm5);
break;
}
// rb = rb.sub16(c[abb * 2 + 0]);
switch(m_sel.abb)
{
case 0:
psubw(xmm5, xmm4);
break;
case 1:
psubw(xmm5, xmm0);
break;
case 2:
break;
}
if(!(m_sel.fpsm == 1 && m_sel.abc == 1))
{
// GSVector4i a = abc < 2 ? c[abc * 2 + 1].yywwlh().sll16(7) : m_env.afix;
switch(m_sel.abc)
{
case 0:
case 1:
movdqa(xmm7, m_sel.abc ? xmm1 : xmm6);
pshuflw(xmm7, xmm7, _MM_SHUFFLE(3, 3, 1, 1));
pshufhw(xmm7, xmm7, _MM_SHUFFLE(3, 3, 1, 1));
psllw(xmm7, 7);
break;
case 2:
movdqa(xmm7, xmmword[&m_env.afix]);
break;
}
// rb = rb.modulate16<1>(a);
modulate16<1>(xmm5, xmm7);
}
// rb = rb.add16(c[abd * 2 + 0]);
switch(m_sel.abd)
{
case 0:
paddw(xmm5, xmm4);
break;
case 1:
paddw(xmm5, xmm0);
break;
case 2:
break;
}
}
else
{
// rb = c[abd * 2 + 0];
switch(m_sel.abd)
{
case 0:
break;
case 1:
movdqa(xmm5, xmm0);
break;
case 2:
pxor(xmm5, xmm5);
break;
}
}
if(m_sel.pabe)
{
// mask = (c[1] << 8).sra32(31);
movdqa(xmm0, xmm6);
pslld(xmm0, 8);
psrad(xmm0, 31);
// rb = c[0].blend8(rb, mask);
blend8r(xmm5, xmm4);
}
// xmm6 = src ga
// xmm1 = dst ga
// xmm5 = rb
// xmm7 = a
// xmm2, xmm3 = used
// xmm0, xmm4 = free
movdqa(xmm4, xmm6);
if(m_sel.aba != m_sel.abb)
{
// ga = c[aba * 2 + 1];
switch(m_sel.aba)
{
case 0:
break;
case 1:
movdqa(xmm6, xmm1);
break;
case 2:
pxor(xmm6, xmm6);
break;
}
// ga = ga.sub16(c[abeb * 2 + 1]);
switch(m_sel.abb)
{
case 0:
psubw(xmm6, xmm4);
break;
case 1:
psubw(xmm6, xmm1);
break;
case 2:
break;
}
if(!(m_sel.fpsm == 1 && m_sel.abc == 1))
{
// ga = ga.modulate16<1>(a);
modulate16<1>(xmm6, xmm7);
}
// ga = ga.add16(c[abd * 2 + 1]);
switch(m_sel.abd)
{
case 0:
paddw(xmm6, xmm4);
break;
case 1:
paddw(xmm6, xmm1);
break;
case 2:
break;
}
}
else
{
// ga = c[abd * 2 + 1];
switch(m_sel.abd)
{
case 0:
break;
case 1:
movdqa(xmm6, xmm1);
break;
case 2:
pxor(xmm6, xmm6);
break;
}
}
// xmm4 = src ga
// xmm5 = rb
// xmm6 = ga
// xmm2, xmm3 = used
// xmm0, xmm1, xmm7 = free
if(m_sel.pabe)
{
if(!m_cpu.has(util::Cpu::tSSE41))
{
// doh, previous blend8r overwrote xmm0 (sse41 uses pblendvb)
movdqa(xmm0, xmm4);
pslld(xmm0, 8);
psrad(xmm0, 31);
}
psrld(xmm0, 16); // zero out high words to select the source alpha in blend (so it also does mix16)
// ga = c[1].blend8(ga, mask).mix16(c[1]);
blend8r(xmm6, xmm4);
}
else
{
if(m_sel.fpsm != 1) // TODO: fm == 0xffxxxxxx
{
mix16(xmm6, xmm4, xmm7);
}
}
}
void GSDrawScanlineCodeGenerator::TestAlpha()
{
switch(m_sel.afail)
{
case AFAIL_FB_ONLY:
if(!m_sel.zwrite) return;
break;
case AFAIL_ZB_ONLY:
if(!m_sel.fwrite) return;
break;
case AFAIL_RGB_ONLY:
if(!m_sel.zwrite && m_sel.fpsm == 1) return;
break;
}
switch(m_sel.atst)
{
case ATST_NEVER:
// t = GSVector4i::xffffffff();
pcmpeqd(xmm1, xmm1);
break;
case ATST_ALWAYS:
return;
case ATST_LESS:
case ATST_LEQUAL:
// t = (ga >> 16) > m_env.aref;
movdqa(xmm1, xmm6);
psrld(xmm1, 16);
pcmpgtd(xmm1, xmmword[&m_env.aref]);
break;
case ATST_EQUAL:
// t = (ga >> 16) != m_env.aref;
movdqa(xmm1, xmm6);
psrld(xmm1, 16);
pcmpeqd(xmm1, xmmword[&m_env.aref]);
pcmpeqd(xmm0, xmm0);
pxor(xmm1, xmm0);
break;
case ATST_GEQUAL:
case ATST_GREATER:
// t = (ga >> 16) < m_env.aref;
movdqa(xmm0, xmm6);
psrld(xmm0, 16);
movdqa(xmm1, xmmword[&m_env.aref]);
pcmpgtd(xmm1, xmm0);
break;
case ATST_NOTEQUAL:
// t = (ga >> 16) == m_env.aref;
movdqa(xmm1, xmm6);
psrld(xmm1, 16);
pcmpeqd(xmm1, xmmword[&m_env.aref]);
break;
}
switch(m_sel.afail)
{
case AFAIL_KEEP:
// test |= t;
por(xmm7, xmm1);
alltrue();
break;
case AFAIL_FB_ONLY:
// zm |= t;
por(xmm4, xmm1);
break;
case AFAIL_ZB_ONLY:
// fm |= t;
por(xmm3, xmm1);
break;
case AFAIL_RGB_ONLY:
// zm |= t;
por(xmm4, xmm1);
// fm |= t & GSVector4i::xff000000();
psrld(xmm1, 24);
pslld(xmm1, 24);
por(xmm3, xmm1);
break;
}
}
void GSDrawScanlineCodeGenerator::AlphaTFX()
{
if(!m_sel.fb)
{
return;
}
switch(m_sel.tfx)
{
case TFX_MODULATE:
// GSVector4i ga = iip ? gaf : m_env.c.ga;
movdqa(xmm4, xmmword[m_sel.iip ? &m_env.temp.ga : &m_env.c.ga]);
// gat = gat.modulate16<1>(ga).clamp8();
modulate16<1>(xmm6, xmm4);
clamp16(xmm6, xmm3);
// if(!tcc) gat = gat.mix16(ga.srl16(7));
if(!m_sel.tcc)
{
psrlw(xmm4, 7);
mix16(xmm6, xmm4, xmm3);
}
break;
case TFX_DECAL:
// if(!tcc) gat = gat.mix16(ga.srl16(7));
if(!m_sel.tcc)
{
// GSVector4i ga = iip ? gaf : m_env.c.ga;
movdqa(xmm4, xmmword[m_sel.iip ? &m_env.temp.ga : &m_env.c.ga]);
psrlw(xmm4, 7);
mix16(xmm6, xmm4, xmm3);
}
break;
case TFX_HIGHLIGHT:
// GSVector4i ga = iip ? gaf : m_env.c.ga;
movdqa(xmm4, xmmword[m_sel.iip ? &m_env.temp.ga : &m_env.c.ga]);
movdqa(xmm2, xmm4);
// gat = gat.mix16(!tcc ? ga.srl16(7) : gat.addus8(ga.srl16(7)));
psrlw(xmm4, 7);
if(m_sel.tcc)
{
paddusb(xmm4, xmm6);
}
mix16(xmm6, xmm4, xmm3);
break;
case TFX_HIGHLIGHT2:
// if(!tcc) gat = gat.mix16(ga.srl16(7));
if(!m_sel.tcc)
{
// GSVector4i ga = iip ? gaf : m_env.c.ga;
movdqa(xmm4, xmmword[m_sel.iip ? &m_env.temp.ga : &m_env.c.ga]);
movdqa(xmm2, xmm4);
psrlw(xmm4, 7);
mix16(xmm6, xmm4, xmm3);
}
break;
case TFX_NONE:
// gat = iip ? ga.srl16(7) : ga;
if(m_sel.iip)
{
psrlw(xmm6, 7);
}
break;
}
if(m_sel.aa1)
{
// gs_user figure 3-2: anti-aliasing after tfx, before tests, modifies alpha
// FIXME: bios config screen cubes
if(!m_sel.abe)
{
// a = cov
if(m_sel.edge)
{
movdqa(xmm0, xmmword[&m_env.temp.cov]);
}
else
{
pcmpeqd(xmm0, xmm0);
psllw(xmm0, 15);
psrlw(xmm0, 8);
}
mix16(xmm6, xmm0, xmm1);
}
else
{
// a = a == 0x80 ? cov : a
pcmpeqd(xmm0, xmm0);
psllw(xmm0, 15);
psrlw(xmm0, 8);
if(m_sel.edge)
{
movdqa(xmm1, xmmword[&m_env.temp.cov]);
}
else
{
movdqa(xmm1, xmm0);
}
pcmpeqw(xmm0, xmm6);
psrld(xmm0, 16);
pslld(xmm0, 16);
blend8(xmm6, xmm1);
}
}
}
