Mostly code cleanups, XBYAK 2.99, VEX conversion for the sw renderer (3-5% faster), GSState::Move fix for dark cloud 2 invention crash.

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@4287 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
gabest11
2011-02-07 01:59:05 +00:00
parent e2d36a53a4
commit ca7abd983a
56 changed files with 6404 additions and 3150 deletions
+489 -205
View File
@@ -48,7 +48,14 @@ void GSSetupPrimCodeGenerator::Generate()
{
for(int i = 0; i < 5; i++)
{
movaps(Xmm(3 + i), xmmword[&m_shift[i]]);
if(m_cpu.has(util::Cpu::tAVX))
{
vmovaps(Xmm(3 + i), ptr[&m_shift[i]]);
}
else
{
movaps(Xmm(3 + i), ptr[&m_shift[i]]);
}
}
}
@@ -68,113 +75,221 @@ void GSSetupPrimCodeGenerator::Depth()
return;
}
if(!m_sel.sprite)
if(m_cpu.has(util::Cpu::tAVX))
{
// GSVector4 t = dscan.p;
movaps(xmm0, xmmword[edx + 16]);
if(m_en.f)
if(!m_sel.sprite)
{
// GSVector4 df = p.wwww();
// GSVector4 t = dscan.p;
movaps(xmm1, xmm0);
shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
vmovaps(xmm0, ptr[edx + 16]);
// 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++)
if(m_en.f)
{
// m_env.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
// GSVector4 df = p.wwww();
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);
vshufps(xmm1, xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
// m_env.d4.f = GSVector4i(df * 4.0f).xxzzlh();
vmulps(xmm2, xmm1, xmm3);
vcvttps2dq(xmm2, xmm2);
vpshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
vpshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
vmovdqa(ptr[&m_env.d4.f], xmm2);
for(int i = 0; i < 4; i++)
{
// m_env.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
vmulps(xmm2, xmm1, Xmm(4 + i));
vcvttps2dq(xmm2, xmm2);
vpshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
vpshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
vmovdqa(ptr[&m_env.d[i].f], xmm2);
}
}
if(m_en.z)
{
// GSVector4 dz = p.zzzz();
vshufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
// m_env.d4.z = dz * 4.0f;
vmulps(xmm1, xmm0, xmm3);
vmovdqa(ptr[&m_env.d4.z], xmm1);
for(int i = 0; i < 4; i++)
{
// m_env.d[i].z = dz * m_shift[i];
vmulps(xmm1, xmm0, Xmm(4 + i));
vmovdqa(ptr[&m_env.d[i].z], xmm1);
}
}
}
if(m_en.z)
else
{
// GSVector4 dz = p.zzzz();
// GSVector4 p = vertices[0].p;
shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
vmovaps(xmm0, ptr[ecx + 16]);
// 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++)
if(m_en.f)
{
// m_env.d[i].z = dz * m_shift[i];
// m_env.p.f = GSVector4i(p).zzzzh().zzzz();
movaps(xmm1, xmm0);
mulps(xmm1, Xmm(4 + i));
movdqa(xmmword[&m_env.d[i].z], xmm1);
vcvttps2dq(xmm1, xmm0);
vpshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
vpshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
vmovdqa(ptr[&m_env.p.f], xmm1);
}
if(m_en.z)
{
// GSVector4 z = p.zzzz();
vshufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
if(m_sel.zoverflow)
{
// m_env.p.z = (GSVector4i(z * 0.5f) << 1) | (GSVector4i(z) & GSVector4i::x00000001());
static const float half = 0.5f;
vmovss(xmm1, dword[&half]);
vshufps(xmm1, xmm1, _MM_SHUFFLE(0, 0, 0, 0));
vmulps(xmm1, xmm0);
vcvttps2dq(xmm1, xmm1);
vpslld(xmm1, 1);
vcvttps2dq(xmm0, xmm0);
vpcmpeqd(xmm2, xmm2);
vpsrld(xmm2, 31);
vpand(xmm0, xmm2);
vpor(xmm0, xmm1);
}
else
{
// m_env.p.z = GSVector4i(z);
vcvttps2dq(xmm0, xmm0);
}
vmovdqa(ptr[&m_env.p.z], xmm0);
}
}
}
else
{
// GSVector4 p = vertices[0].p;
movaps(xmm0, xmmword[ecx + 16]);
if(m_en.f)
if(!m_sel.sprite)
{
// m_env.p.f = GSVector4i(p).zzzzh().zzzz();
// GSVector4 t = dscan.p;
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);
movaps(xmm0, ptr[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(ptr[&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(ptr[&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(ptr[&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(ptr[&m_env.d[i].z], xmm1);
}
}
}
if(m_en.z)
else
{
// GSVector4 z = p.zzzz();
// GSVector4 p = vertices[0].p;
shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
movaps(xmm0, ptr[ecx + 16]);
if(m_sel.zoverflow)
if(m_en.f)
{
// m_env.p.z = (GSVector4i(z * 0.5f) << 1) | (GSVector4i(z) & GSVector4i::x00000001());
// m_env.p.f = GSVector4i(p).zzzzh().zzzz();
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);
cvttps2dq(xmm1, xmm0);
pshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
pshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
movdqa(ptr[&m_env.p.f], xmm1);
}
movdqa(xmmword[&m_env.p.z], xmm0);
if(m_en.z)
{
// GSVector4 z = p.zzzz();
shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
if(m_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(ptr[&m_env.p.z], xmm0);
}
}
}
}
@@ -186,64 +301,129 @@ void GSSetupPrimCodeGenerator::Texture()
return;
}
// GSVector4 t = dscan.t;
movaps(xmm0, xmmword[edx + 32]);
movaps(xmm1, xmm0);
mulps(xmm1, xmm3);
if(m_sel.fst)
if(m_cpu.has(util::Cpu::tAVX))
{
// m_env.d4.st = GSVector4i(t * 4.0f);
// GSVector4 t = dscan.t;
cvttps2dq(xmm1, xmm1);
movdqa(xmmword[&m_env.d4.st], xmm1);
vmovaps(xmm0, ptr[edx + 32]);
vmulps(xmm1, xmm0, xmm3);
if(m_sel.fst)
{
// m_env.d4.st = GSVector4i(t * 4.0f);
vcvttps2dq(xmm1, xmm1);
vmovdqa(ptr[&m_env.d4.st], xmm1);
}
else
{
// m_env.d4.stq = t * 4.0f;
vmovaps(ptr[&m_env.d4.stq], xmm1);
}
for(int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
{
// GSVector4 ds = t.xxxx();
// GSVector4 dt = t.yyyy();
// GSVector4 dq = t.zzzz();
vshufps(xmm1, xmm0, xmm0, (uint8)_MM_SHUFFLE(j, j, j, j));
for(int i = 0; i < 4; i++)
{
// GSVector4 v = ds/dt * m_shift[i];
vmulps(xmm2, xmm1, Xmm(4 + i));
if(m_sel.fst)
{
// m_env.d[i].si/ti = GSVector4i(v);
vcvttps2dq(xmm2, xmm2);
switch(j)
{
case 0: vmovdqa(ptr[&m_env.d[i].si], xmm2); break;
case 1: vmovdqa(ptr[&m_env.d[i].ti], xmm2); break;
}
}
else
{
// m_env.d[i].s/t/q = v;
switch(j)
{
case 0: vmovaps(ptr[&m_env.d[i].s], xmm2); break;
case 1: vmovaps(ptr[&m_env.d[i].t], xmm2); break;
case 2: vmovaps(ptr[&m_env.d[i].q], xmm2); break;
}
}
}
}
}
else
{
// m_env.d4.stq = t * 4.0f;
// GSVector4 t = dscan.t;
movaps(xmmword[&m_env.d4.stq], xmm1);
}
for(int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
{
// GSVector4 ds = t.xxxx();
// GSVector4 dt = t.yyyy();
// GSVector4 dq = t.zzzz();
movaps(xmm0, ptr[edx + 32]);
movaps(xmm1, xmm0);
shufps(xmm1, xmm1, (uint8)_MM_SHUFFLE(j, j, j, j));
mulps(xmm1, xmm3);
for(int i = 0; i < 4; i++)
if(m_sel.fst)
{
// GSVector4 v = ds/dt * m_shift[i];
// m_env.d4.st = GSVector4i(t * 4.0f);
movaps(xmm2, xmm1);
mulps(xmm2, Xmm(4 + i));
cvttps2dq(xmm1, xmm1);
movdqa(ptr[&m_env.d4.st], xmm1);
}
else
{
// m_env.d4.stq = t * 4.0f;
if(m_sel.fst)
movaps(ptr[&m_env.d4.stq], xmm1);
}
for(int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
{
// GSVector4 ds = t.xxxx();
// GSVector4 dt = t.yyyy();
// GSVector4 dq = t.zzzz();
movaps(xmm1, xmm0);
shufps(xmm1, xmm1, (uint8)_MM_SHUFFLE(j, j, j, j));
for(int i = 0; i < 4; i++)
{
// m_env.d[i].si/ti = GSVector4i(v);
// GSVector4 v = ds/dt * m_shift[i];
cvttps2dq(xmm2, xmm2);
movaps(xmm2, xmm1);
mulps(xmm2, Xmm(4 + i));
switch(j)
if(m_sel.fst)
{
case 0: movdqa(xmmword[&m_env.d[i].si], xmm2); break;
case 1: movdqa(xmmword[&m_env.d[i].ti], xmm2); break;
// m_env.d[i].si/ti = GSVector4i(v);
cvttps2dq(xmm2, xmm2);
switch(j)
{
case 0: movdqa(ptr[&m_env.d[i].si], xmm2); break;
case 1: movdqa(ptr[&m_env.d[i].ti], xmm2); break;
}
}
}
else
{
// m_env.d[i].s/t/q = v;
switch(j)
else
{
case 0: movaps(xmmword[&m_env.d[i].s], xmm2); break;
case 1: movaps(xmmword[&m_env.d[i].t], xmm2); break;
case 2: movaps(xmmword[&m_env.d[i].q], xmm2); break;
// m_env.d[i].s/t/q = v;
switch(j)
{
case 0: movaps(ptr[&m_env.d[i].s], xmm2); break;
case 1: movaps(ptr[&m_env.d[i].t], xmm2); break;
case 2: movaps(ptr[&m_env.d[i].q], xmm2); break;
}
}
}
}
@@ -257,113 +437,217 @@ void GSSetupPrimCodeGenerator::Color()
return;
}
if(m_sel.iip)
if(m_cpu.has(util::Cpu::tAVX))
{
// GSVector4 c = dscan.c;
movaps(xmm0, xmmword[edx]);
movaps(xmm1, xmm0);
// m_env.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
movaps(xmm2, xmm0);
mulps(xmm2, xmm3);
cvttps2dq(xmm2, xmm2);
pshufd(xmm2, xmm2, _MM_SHUFFLE(3, 1, 2, 0));
packssdw(xmm2, xmm2);
movdqa(xmmword[&m_env.d4.c], xmm2);
// xmm3 is not needed anymore
// GSVector4 dr = c.xxxx();
// GSVector4 db = c.zzzz();
shufps(xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
shufps(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
for(int i = 0; i < 4; i++)
if(m_sel.iip)
{
// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
// GSVector4 c = dscan.c;
movaps(xmm2, xmm0);
mulps(xmm2, Xmm(4 + i));
cvttps2dq(xmm2, xmm2);
packssdw(xmm2, xmm2);
vmovaps(xmm0, ptr[edx]);
// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
// m_env.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
movaps(xmm3, xmm1);
mulps(xmm3, Xmm(4 + i));
cvttps2dq(xmm3, xmm3);
packssdw(xmm3, xmm3);
vmulps(xmm1, xmm0, xmm3);
vcvttps2dq(xmm1, xmm1);
vpshufd(xmm1, xmm1, _MM_SHUFFLE(3, 1, 2, 0));
vpackssdw(xmm1, xmm1);
vmovdqa(ptr[&m_env.d4.c], xmm1);
// m_env.d[i].rb = r.upl16(b);
// xmm3 is not needed anymore
punpcklwd(xmm2, xmm3);
movdqa(xmmword[&m_env.d[i].rb], xmm2);
// GSVector4 dr = c.xxxx();
// GSVector4 db = c.zzzz();
vshufps(xmm2, xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vshufps(xmm3, xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
for(int i = 0; i < 4; i++)
{
// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
vmulps(xmm0, xmm2, Xmm(4 + i));
vcvttps2dq(xmm0, xmm0);
vpackssdw(xmm0, xmm0);
// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
vmulps(xmm1, xmm3, Xmm(4 + i));
vcvttps2dq(xmm1, xmm1);
vpackssdw(xmm1, xmm1);
// m_env.d[i].rb = r.upl16(b);
vpunpcklwd(xmm0, xmm1);
vmovdqa(ptr[&m_env.d[i].rb], xmm0);
}
// GSVector4 c = dscan.c;
vmovaps(xmm0, ptr[edx]); // not enough regs, have to reload it
// GSVector4 dg = c.yyyy();
// GSVector4 da = c.wwww();
vshufps(xmm2, xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
vshufps(xmm3, xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
for(int i = 0; i < 4; i++)
{
// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
vmulps(xmm0, xmm2, Xmm(4 + i));
vcvttps2dq(xmm0, xmm0);
vpackssdw(xmm0, xmm0);
// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
vmulps(xmm1, xmm3, Xmm(4 + i));
vcvttps2dq(xmm1, xmm1);
vpackssdw(xmm1, xmm1);
// m_env.d[i].ga = g.upl16(a);
vpunpcklwd(xmm0, xmm1);
vmovdqa(ptr[&m_env.d[i].ga], xmm0);
}
}
// GSVector4 c = dscan.c;
movaps(xmm0, xmmword[edx]); // not enough regs, have to reload it
movaps(xmm1, xmm0);
// GSVector4 dg = c.yyyy();
// GSVector4 da = c.wwww();
shufps(xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
for(int i = 0; i < 4; i++)
else
{
// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
// GSVector4i c = GSVector4i(vertices[0].c);
movaps(xmm2, xmm0);
mulps(xmm2, Xmm(4 + i));
cvttps2dq(xmm2, xmm2);
packssdw(xmm2, xmm2);
vcvttps2dq(xmm0, ptr[ecx]);
// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
// c = c.upl16(c.zwxy());
movaps(xmm3, xmm1);
mulps(xmm3, Xmm(4 + i));
cvttps2dq(xmm3, xmm3);
packssdw(xmm3, xmm3);
vpshufd(xmm1, xmm0, _MM_SHUFFLE(1, 0, 3, 2));
vpunpcklwd(xmm0, xmm1);
// m_env.d[i].ga = g.upl16(a);
// if(!tme) c = c.srl16(7);
punpcklwd(xmm2, xmm3);
movdqa(xmmword[&m_env.d[i].ga], xmm2);
if(m_sel.tfx == TFX_NONE)
{
vpsrlw(xmm0, 7);
}
// m_env.c.rb = c.xxxx();
// m_env.c.ga = c.zzzz();
vpshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vpshufd(xmm2, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
vmovdqa(ptr[&m_env.c.rb], xmm1);
vmovdqa(ptr[&m_env.c.ga], xmm2);
}
}
else
{
// GSVector4i c = GSVector4i(vertices[0].c);
movaps(xmm0, xmmword[ecx]);
cvttps2dq(xmm0, xmm0);
// c = c.upl16(c.zwxy());
movdqa(xmm1, xmm0);
pshufd(xmm1, xmm1, _MM_SHUFFLE(1, 0, 3, 2));
punpcklwd(xmm0, xmm1);
// if(!tme) c = c.srl16(7);
if(m_sel.tfx == TFX_NONE)
if(m_sel.iip)
{
psrlw(xmm0, 7);
// GSVector4 c = dscan.c;
movaps(xmm0, ptr[edx]);
movaps(xmm1, xmm0);
// m_env.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
movaps(xmm2, xmm0);
mulps(xmm2, xmm3);
cvttps2dq(xmm2, xmm2);
pshufd(xmm2, xmm2, _MM_SHUFFLE(3, 1, 2, 0));
packssdw(xmm2, xmm2);
movdqa(ptr[&m_env.d4.c], xmm2);
// xmm3 is not needed anymore
// GSVector4 dr = c.xxxx();
// GSVector4 db = c.zzzz();
shufps(xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
shufps(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
for(int i = 0; i < 4; i++)
{
// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
movaps(xmm2, xmm0);
mulps(xmm2, Xmm(4 + i));
cvttps2dq(xmm2, xmm2);
packssdw(xmm2, xmm2);
// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
movaps(xmm3, xmm1);
mulps(xmm3, Xmm(4 + i));
cvttps2dq(xmm3, xmm3);
packssdw(xmm3, xmm3);
// m_env.d[i].rb = r.upl16(b);
punpcklwd(xmm2, xmm3);
movdqa(ptr[&m_env.d[i].rb], xmm2);
}
// GSVector4 c = dscan.c;
movaps(xmm0, ptr[edx]); // not enough regs, have to reload it
movaps(xmm1, xmm0);
// GSVector4 dg = c.yyyy();
// GSVector4 da = c.wwww();
shufps(xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
for(int i = 0; i < 4; i++)
{
// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
movaps(xmm2, xmm0);
mulps(xmm2, Xmm(4 + i));
cvttps2dq(xmm2, xmm2);
packssdw(xmm2, xmm2);
// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
movaps(xmm3, xmm1);
mulps(xmm3, Xmm(4 + i));
cvttps2dq(xmm3, xmm3);
packssdw(xmm3, xmm3);
// m_env.d[i].ga = g.upl16(a);
punpcklwd(xmm2, xmm3);
movdqa(ptr[&m_env.d[i].ga], xmm2);
}
}
else
{
// GSVector4i c = GSVector4i(vertices[0].c);
// m_env.c.rb = c.xxxx();
// m_env.c.ga = c.zzzz();
movaps(xmm0, ptr[ecx]);
cvttps2dq(xmm0, xmm0);
movdqa(xmm1, xmm0);
pshufd(xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
pshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
movdqa(xmmword[&m_env.c.rb], xmm0);
movdqa(xmmword[&m_env.c.ga], xmm1);
// c = c.upl16(c.zwxy());
pshufd(xmm1, xmm0, _MM_SHUFFLE(1, 0, 3, 2));
punpcklwd(xmm0, xmm1);
// if(!tme) c = c.srl16(7);
if(m_sel.tfx == TFX_NONE)
{
psrlw(xmm0, 7);
}
// m_env.c.rb = c.xxxx();
// m_env.c.ga = c.zzzz();
pshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
pshufd(xmm2, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
movdqa(ptr[&m_env.c.rb], xmm1);
movdqa(ptr[&m_env.c.ga], xmm2);
}
}
}