time_t
State::synch_update_internals(
time_t present_time
, std::vector<EventBase *> & expired
, std::vector<EventBase *> & cancelled)
{
{ // handle the new Events added
LockFreeList<EventBase *> toadd;
_new_list.swap(toadd);
toadd.fold<State>(&update_folds::add,*this);
}
{ // handle the cancels
LockFreeList<size_t> tocancel;
_cancel_list.swap(tocancel);
update_folds::StateAndRemoves sar(*this,cancelled);
tocancel.fold<update_folds::StateAndRemoves>(&update_folds::remove,sar);
}
// find expired
std::multimap<time_t,EventBase *>::iterator mmitr = _map_by_time.begin();
while(mmitr != _map_by_time.end() && (*mmitr).first <= present_time) {
expired.push_back((*mmitr).second);
++mmitr;
}
// remove expired from internal structures
std::vector<EventBase *>::iterator vitr = expired.begin();
while(vitr != expired.end()) {
remove((*vitr)->id());
++vitr;
}
return until_time;
}
PlanIter_t XQueryCompiler::compile(
std::istream& aXQuery,
const zstring& aFileName,
ulong& nextDynamicVarId)
{
audit::Event* ae = theCompilerCB->theRootSctx->get_audit_event();
zorba::audit::ScopedRecord sar(ae);
const char* lFileName = aFileName.c_str();
audit::ScopedAuditor<const char*>
filenameAudit(sar, zorba::audit::XQUERY_COMPILATION_FILENAME, lFileName);
parsenode_t lAST;
{
time::Timer lTimer;
audit::DurationAuditor
durationAudit(sar, audit::XQUERY_COMPILATION_PARSE_DURATION, lTimer);
lAST = parse(aXQuery, aFileName);
if (theCompilerCB->theConfig.lib_module &&
dynamic_cast<LibraryModule*>(lAST.getp()) != NULL)
{
lAST = createMainModule(lAST, aXQuery, aFileName);
}
}
return compile(lAST, true, nextDynamicVarId, sar);
}
int main()
{
{
Sorcerer robert("Robert", "the Magnificient");
Victim jim("Jimmy");
Peon joe("Joe");
std::cout << robert << jim << joe;
robert.polymorph(jim);
robert.polymorph(joe);
}
{
Victim joe("Joe");
Victim sarah = joe;
Victim bob(sarah);
std::cout << joe << sarah << bob;
joe.getPolymorphed();
sarah.getPolymorphed();
bob.getPolymorphed();
Peon pepe("Pepe");
Peon carl = pepe;
Peon martin(carl);
Victim bobby = martin;
Victim sar(carl);
std::cout << pepe << carl << martin << bobby << sar;
}
return 0;
}
void LuaWrapper::AddPackagePath(const char* path) {
StackAutoRecover sar(m_luaState);
lua_getglobal(m_luaState, "package");
lua_getfield(m_luaState, -1, "path");
lua_pushfstring(m_luaState, "%s;%s/?.lua", lua_tostring(m_luaState, -1), path);
lua_setfield(m_luaState, -3, "path");
}
void LuaWrapper::DoString(const char* text) {
StackAutoRecover sar(m_luaState);
const auto errFunc = GetErrorFunction(m_luaState);
const auto result = luaL_loadstring(m_luaState, text);
if (result == LUA_OK) {
lua_pcall(m_luaState, 0, LUA_MULTRET, errFunc);
}
}
void LuaWrapper::DoScript(const char* file) {
StackAutoRecover sar(m_luaState);
const auto errFunc = GetErrorFunction(m_luaState);
const auto result = luaL_loadfile(m_luaState, file);
if (result == LUA_OK) {
lua_pcall(m_luaState, 0, LUA_MULTRET, errFunc);
}
}
int check(int a,int b){
int i;
int s=a*b;
rect rt;
for(i=0;i<arc;i++){
rt=ary[i];
s-=sar(rt);
}
if(s)return 1;
return 0;
}
int main(int argc, char *argv[])
{
const time_t t0 = time(NULL);
// Random number generator
unsigned int seed = t0;
// Run the model
sar(argv, seed);
std::cout << "Time elasped: " << (time(NULL) - t0) << " seconds." << std::endl;
return 0;
}
int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
{
GKC::ConstArray<GKC::ConstStringS> args, env;
//memory
_auto_mem spArgs, spEnv;
//convert
_cmdline_to_strings(argc, argv, envp, spArgs, spEnv, args, env); //may throw
//stdout
stdout_attr_helper::get_attr().Init();
stdout_attr_restore sar(stdout_attr_helper::get_attr());
//locale
set_default_locale();
//main
return ProgramEntryPoint::ConsoleMain(args, env);
}
int main(int argc, char *argv[], char *envp[])
{
const_array<const_string_s> args, env;
//memory
_auto_mem spArgs, spEnv;
//convert
_cmdline_to_strings(argc, argv, envp, spArgs, spEnv, args, env); //may throw
//stdout
stdout_attr_helper::get_attr().Init();
stdout_attr_restore sar(stdout_attr_helper::get_attr());
//locale
set_default_locale();
//signal
::signal(SIGINT, __sig_int); //no check
//main
return program_entry_point::ConsoleMain(args, env);
}
void GSDrawScanlineCodeGenerator::Step()
{
// steps -= 4;
sub(rcx, 4);
// fza_offset++;
add(rdi, 8);
if(!m_sel.sprite)
{
// z += m_local.d4.z;
if(m_sel.zb)
{
vaddps(xmm8, ptr[r11 + offsetof(GSScanlineLocalData, d4.z)]);
}
// f = f.add16(m_local.d4.f);
if(m_sel.fwrite && m_sel.fge)
{
vpaddw(xmm9, ptr[r11 + offsetof(GSScanlineLocalData, d4.f)]);
}
}
else
{
if(m_sel.ztest)
{
}
}
if(m_sel.fb)
{
if(m_sel.tfx != TFX_NONE)
{
if(m_sel.fst)
{
// GSVector4i st = m_local.d4.st;
// si += st.xxxx();
// if(!sprite) ti += st.yyyy();
vmovdqa(xmm0, ptr[r11 + offsetof(GSScanlineLocalData, d4.stq)]);
vpshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vpaddd(xmm10, xmm1);
if(!m_sel.sprite || m_sel.mmin)
{
vpshufd(xmm1, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
vpaddd(xmm11, xmm1);
}
}
else
{
// GSVector4 stq = m_local.d4.stq;
// s += stq.xxxx();
// t += stq.yyyy();
// q += stq.zzzz();
vmovaps(xmm0, ptr[r11 + offsetof(GSScanlineLocalData, d4.stq)]);
vshufps(xmm1, xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vshufps(xmm2, xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
vshufps(xmm3, xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
vaddps(xmm10, xmm1);
vaddps(xmm11, xmm2);
vaddps(xmm12, xmm3);
}
}
if(!(m_sel.tfx == TFX_DECAL && m_sel.tcc))
{
if(m_sel.iip)
{
// GSVector4i c = m_local.d4.c;
// rb = rb.add16(c.xxxx());
// ga = ga.add16(c.yyyy());
vmovdqa(xmm0, ptr[r11 + offsetof(GSScanlineLocalData, d4.c)]);
vpshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vpshufd(xmm2, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
vpaddw(xmm13, xmm1);
vpaddw(xmm14, xmm2);
// FIXME: color may underflow and roll over at the end of the line, if decreasing
vpxor(xmm0, xmm0);
vpmaxsw(xmm13, xmm0);
vpmaxsw(xmm14, xmm0);
}
else
{
if(m_sel.tfx == TFX_NONE)
{
}
}
}
}
// test = m_test[7 + (steps & (steps >> 31))];
mov(rdx, rcx);
sar(rdx, 63);
and(rdx, rcx);
shl(rdx, 4);
vmovdqa(xmm15, ptr[rdx + r10 + 7 * 16]);
}
void GSDrawScanlineCodeGenerator::Init()
{
// int skip = left & 3;
mov(rbx, rdx);
and(rdx, 3);
// left -= skip;
sub(rbx, rdx);
// int steps = pixels + skip - 4;
lea(rcx, ptr[rcx + rdx - 4]);
// GSVector4i test = m_test[skip] | m_test[7 + (steps & (steps >> 31))];
shl(rdx, 4);
vmovdqa(xmm15, ptr[rdx + r10]);
mov(rax, rcx);
sar(rax, 63);
and(rax, rcx);
shl(rax, 4);
vpor(xmm15, ptr[rax + r10 + 7 * 16]);
// GSVector2i* fza_base = &m_local.gd->fzbr[top];
mov(rax, (size_t)m_local.gd->fzbr);
lea(rsi, ptr[rax + r8 * 8]);
// GSVector2i* fza_offset = &m_local.gd->fzbc[left >> 2];
mov(rax, (size_t)m_local.gd->fzbc);
lea(rdi, ptr[rax + rbx * 2]);
if(!m_sel.sprite && (m_sel.fwrite && m_sel.fge || m_sel.zb) || m_sel.fb && (m_sel.edge || m_sel.tfx != TFX_NONE || m_sel.iip))
{
// edx = &m_local.d[skip]
lea(rdx, ptr[rdx * 8 + r11 + offsetof(GSScanlineLocalData, d)]);
}
if(!m_sel.sprite)
{
if(m_sel.fwrite && m_sel.fge || m_sel.zb)
{
vmovaps(xmm0, ptr[r9 + offsetof(GSVertexSW, p)]); // v.p
if(m_sel.fwrite && m_sel.fge)
{
// f = GSVector4i(vp).zzzzh().zzzz().add16(m_local.d[skip].f);
vcvttps2dq(xmm9, xmm0);
vpshufhw(xmm9, xmm9, _MM_SHUFFLE(2, 2, 2, 2));
vpshufd(xmm9, xmm9, _MM_SHUFFLE(2, 2, 2, 2));
vpaddw(xmm9, ptr[rdx + 16 * 6]);
}
if(m_sel.zb)
{
// z = vp.zzzz() + m_local.d[skip].z;
vshufps(xmm8, xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
vaddps(xmm8, ptr[rdx]);
}
}
}
else
{
if(m_sel.ztest)
{
vmovdqa(xmm8, ptr[r11 + offsetof(GSScanlineLocalData, p.z)]);
}
}
if(m_sel.fb)
{
if(m_sel.edge || m_sel.tfx != TFX_NONE)
{
vmovaps(xmm0, ptr[r9 + offsetof(GSVertexSW, t)]); // v.t
}
if(m_sel.edge)
{
vpshufhw(xmm1, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
vpshufd(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
vpsrlw(xmm1, 9);
vmovdqa(ptr[r11 + offsetof(GSScanlineLocalData, temp.cov)], xmm1);
}
if(m_sel.tfx != TFX_NONE)
{
if(m_sel.fst)
{
// GSVector4i vti(vt);
vcvttps2dq(xmm0, xmm0);
// s = vti.xxxx() + m_local.d[skip].s;
// t = vti.yyyy(); if(!sprite) t += m_local.d[skip].t;
vpshufd(xmm10, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vpshufd(xmm11, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
vpaddd(xmm10, ptr[rdx + offsetof(GSScanlineLocalData::skip, s)]);
if(!m_sel.sprite || m_sel.mmin)
{
vpaddd(xmm11, ptr[rdx + offsetof(GSScanlineLocalData::skip, t)]);
}
else
{
if(m_sel.ltf)
{
vpshuflw(xmm6, xmm11, _MM_SHUFFLE(2, 2, 0, 0));
vpshufhw(xmm6, xmm6, _MM_SHUFFLE(2, 2, 0, 0));
vpsrlw(xmm6, 1);
}
}
}
else
{
// s = vt.xxxx() + m_local.d[skip].s;
// t = vt.yyyy() + m_local.d[skip].t;
// q = vt.zzzz() + m_local.d[skip].q;
vshufps(xmm10, xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vshufps(xmm11, xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
vshufps(xmm12, xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
vaddps(xmm10, ptr[rdx + offsetof(GSScanlineLocalData::skip, s)]);
vaddps(xmm11, ptr[rdx + offsetof(GSScanlineLocalData::skip, t)]);
vaddps(xmm12, ptr[rdx + offsetof(GSScanlineLocalData::skip, q)]);
}
}
if(!(m_sel.tfx == TFX_DECAL && m_sel.tcc))
{
if(m_sel.iip)
{
// GSVector4i vc = GSVector4i(v.c);
vcvttps2dq(xmm0, ptr[r9 + offsetof(GSVertexSW, c)]); // v.c
// vc = vc.upl16(vc.zwxy());
vpshufd(xmm1, xmm0, _MM_SHUFFLE(1, 0, 3, 2));
vpunpcklwd(xmm0, xmm1);
// rb = vc.xxxx().add16(m_local.d[skip].rb);
// ga = vc.zzzz().add16(m_local.d[skip].ga);
vpshufd(xmm13, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
vpshufd(xmm14, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
vpaddw(xmm13, ptr[rdx + offsetof(GSScanlineLocalData::skip, rb)]);
vpaddw(xmm14, ptr[rdx + offsetof(GSScanlineLocalData::skip, ga)]);
}
else
{
vmovdqa(xmm13, ptr[r11 + offsetof(GSScanlineLocalData, c.rb)]);
vmovdqa(xmm14, ptr[r11 + offsetof(GSScanlineLocalData, c.ga)]);
}
}
}
}
void GPUDrawScanlineCodeGenerator::Generate()
{
push(esi);
push(edi);
Init();
align(16);
L("loop");
// GSVector4i test = m_test[7 + (steps & (steps >> 31))];
mov(edx, ecx);
sar(edx, 31);
and(edx, ecx);
shl(edx, 4);
movdqa(xmm7, ptr[edx + (size_t)&m_test[7]]);
// movdqu(xmm1, ptr[edi]);
movq(xmm1, qword[edi]);
movhps(xmm1, qword[edi + 8]);
// ecx = steps
// esi = tex (tme)
// edi = fb
// xmm1 = fd
// xmm2 = s
// xmm3 = t
// xmm4 = r
// xmm5 = g
// xmm6 = b
// xmm7 = test
TestMask();
SampleTexture();
// xmm1 = fd
// xmm3 = a
// xmm4 = r
// xmm5 = g
// xmm6 = b
// xmm7 = test
// xmm0, xmm2 = free
ColorTFX();
AlphaBlend();
Dither();
WriteFrame();
L("step");
// if(steps <= 0) break;
test(ecx, ecx);
jle("exit", T_NEAR);
Step();
jmp("loop", T_NEAR);
L("exit");
pop(edi);
pop(esi);
ret(8);
}
struct code encode(struct instruction instr)
{
switch (instr.opcode) {
case INSTR_ADD:
return add(instr.optype, instr.source, instr.dest);
case INSTR_NOT:
return not(instr.optype, instr.source);
case INSTR_MUL:
return mul(instr.optype, instr.source);
case INSTR_XOR:
return xor(instr.optype, instr.source, instr.dest);
case INSTR_DIV:
return encode_div(instr.optype, instr.source);
case INSTR_AND:
return and(instr.optype, instr.source, instr.dest);
case INSTR_OR:
return or(instr.optype, instr.source, instr.dest);
case INSTR_SHL:
return shl(instr.optype, instr.source, instr.dest);
case INSTR_SHR:
return shr(instr.optype, instr.source, instr.dest);
case INSTR_SAR:
return sar(instr.optype, instr.source, instr.dest);
case INSTR_CALL:
return call(instr.optype, instr.source);
case INSTR_CMP:
return cmp(instr.optype, instr.source, instr.dest);
case INSTR_MOV:
return mov(instr.optype, instr.source, instr.dest);
case INSTR_MOVSX:
return movsx(instr.optype, instr.source, instr.dest);
case INSTR_MOVZX:
return movzx(instr.optype, instr.source, instr.dest);
case INSTR_MOVAPS:
return movaps(instr.optype, instr.source, instr.dest);
case INSTR_PUSH:
return push(instr.optype, instr.source);
case INSTR_SUB:
return sub(instr.optype, instr.source, instr.dest);
case INSTR_LEA:
return lea(instr.optype, instr.source, instr.dest);
case INSTR_LEAVE:
return leave();
case INSTR_REP_MOVSQ:
assert(instr.optype == OPT_NONE);
return rep_movsq();
case INSTR_RET:
return ret();
case INSTR_JMP:
return jmp(instr.optype, instr.source);
case INSTR_JA:
return jcc(instr.optype, TEST_A, instr.source);
case INSTR_JG:
return jcc(instr.optype, TEST_G, instr.source);
case INSTR_JZ:
return jcc(instr.optype, TEST_Z, instr.source);
case INSTR_JAE:
return jcc(instr.optype, TEST_AE, instr.source);
case INSTR_JGE:
return jcc(instr.optype, TEST_GE, instr.source);
case INSTR_SETZ:
return setcc(instr.optype, TEST_Z, instr.source);
case INSTR_SETA:
return setcc(instr.optype, TEST_A, instr.source);
case INSTR_SETG:
return setcc(instr.optype, TEST_G, instr.source);
case INSTR_SETAE:
return setcc(instr.optype, TEST_AE, instr.source);
case INSTR_SETGE:
return setcc(instr.optype, TEST_GE, instr.source);
case INSTR_TEST:
return test(instr.optype, instr.source, instr.dest);
default:
return nop();
}
}
main () {
FILE *fin = fopen ("rect1.in", "r");
FILE *fout = fopen ("rect1.out", "w");
//fout=stdout;
int aa,ab,an;
int i,j,cr;
rect rt,rti,*rp;
fscanf (fin, "%d %d %d", &aa,&ab,&an);
rt.lx=0;rt.ly=0;rt.rx=aa;rt.ry=ab;rt.clr=1;
ary[0]=rt;
arc=1;rp=ary+arc;
for(i=1;i<=an;i++){
fscanf (fin, "%d %d %d %d %d", &rt.lx,&rt.ly,&rt.rx,&rt.ry,&rt.clr);
//add rt to ary,split rects.
for(j=0;j<arc;j++){
rti=ary[j];
if(rt.lx>=rti.rx||rt.rx<=rti.lx||rt.ly>=rti.ry||rt.ry<=rti.ly)continue;
//rp=ary+arc;
cr=0;
if(rti.lx<rt.lx){
rp->lx=rti.lx;
rp->ly=rti.ly;
rp->rx=rt.lx;
rp->ry=rti.ry;
rp->clr=rti.clr;
rp++;cr++;
rti.lx=rt.lx;
}
if(rti.rx>rt.rx){
rp->lx=rt.rx;
rp->ly=rti.ly;
rp->rx=rti.rx;
rp->ry=rti.ry;
rp->clr=rti.clr;
rp++;cr++;
rti.rx=rt.rx;
}
if(rti.ly<rt.ly){
rp->lx=rti.lx;
rp->ly=rti.ly;
rp->rx=rti.rx;
rp->ry=rt.ly;
rp->clr=rti.clr;
rp++;cr++;
rti.ly=rt.ly;
}
if(rti.ry>rt.ry){
rp->lx=rti.lx;
rp->ly=rt.ry;
rp->rx=rti.rx;
rp->ry=rti.ry;
rp->clr=rti.clr;
rp++;cr++;
rti.ry=rt.ry;
}
assert(rp-ary<=xn);
{rp--;ary[j]=rp[0];}//dont waste ary[j]
if(rp-ary<arc){arc--;j--;}//this is the hard case
}
rp[0]=rt;rp++;
arc=rp-ary;
assert(check(aa,ab)==0);
}
arc=rp-ary;
for(i=0;i<arc;i++){
rt=ary[i];
ara[rt.clr]+=sar(rt);
}
for(i=1;i<xc+1;i++){
if(ara[i]>0)
fprintf (fout, "%d %d\n",i,ara[i]);
}
exit (0);
}
void GSDrawScanlineCodeGenerator::Init(int params)
{
const int _top = params + 4;
const int _v = params + 8;
// int skip = left & 3;
mov(ebx, edx);
and(edx, 3);
// left -= skip;
sub(ebx, edx);
// int steps = right - left - 4;
sub(ecx, ebx);
sub(ecx, 4);
// GSVector4i test = m_test[skip] | m_test[7 + (steps & (steps >> 31))];
shl(edx, 4);
movdqa(xmm7, xmmword[edx + (size_t)&m_test[0]]);
mov(eax, ecx);
sar(eax, 31);
and(eax, ecx);
shl(eax, 4);
por(xmm7, xmmword[eax + (size_t)&m_test[7]]);
// GSVector2i* fza_base = &m_env.fzbr[top];
mov(esi, dword[esp + _top]);
lea(esi, ptr[esi * 8]);
add(esi, dword[&m_env.fzbr]);
// GSVector2i* fza_offset = &m_env.fzbc[left >> 2];
lea(edi, ptr[ebx * 2]);
add(edi, dword[&m_env.fzbc]);
if(!m_sel.sprite && (m_sel.fwrite && m_sel.fge || m_sel.zb) || m_sel.fb && (m_sel.edge || m_sel.tfx != TFX_NONE || m_sel.iip))
{
// edx = &m_env.d[skip]
shl(edx, 4);
lea(edx, ptr[edx + (size_t)m_env.d]);
// ebx = &v
mov(ebx, dword[esp + _v]);
}
if(!m_sel.sprite)
{
if(m_sel.fwrite && m_sel.fge || m_sel.zb)
{
movaps(xmm0, xmmword[ebx + 16]); // v.p
if(m_sel.fwrite && m_sel.fge)
{
// f = GSVector4i(vp).zzzzh().zzzz().add16(m_env.d[skip].f);
cvttps2dq(xmm1, xmm0);
pshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
pshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
paddw(xmm1, xmmword[edx + 16 * 6]);
movdqa(xmmword[&m_env.temp.f], xmm1);
}
if(m_sel.zb)
{
// z = vp.zzzz() + m_env.d[skip].z;
shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
addps(xmm0, xmmword[edx]);
movaps(xmmword[&m_env.temp.z], xmm0);
}
}
}
else
{
if(m_sel.ztest)
{
movdqa(xmm0, xmmword[&m_env.p.z]);
}
}
if(m_sel.fb)
{
if(m_sel.edge || m_sel.tfx != TFX_NONE)
{
movaps(xmm4, xmmword[ebx + 32]); // v.t
}
if(m_sel.edge)
{
pshufhw(xmm3, xmm4, _MM_SHUFFLE(2, 2, 2, 2));
pshufd(xmm3, xmm3, _MM_SHUFFLE(3, 3, 3, 3));
psrlw(xmm3, 9);
movdqa(xmmword[&m_env.temp.cov], xmm3);
}
if(m_sel.tfx != TFX_NONE)
{
if(m_sel.fst)
{
// GSVector4i vti(vt);
cvttps2dq(xmm4, xmm4);
// si = vti.xxxx() + m_env.d[skip].si;
// ti = vti.yyyy(); if(!sprite) ti += m_env.d[skip].ti;
pshufd(xmm2, xmm4, _MM_SHUFFLE(0, 0, 0, 0));
pshufd(xmm3, xmm4, _MM_SHUFFLE(1, 1, 1, 1));
paddd(xmm2, xmmword[edx + 16 * 7]);
if(!m_sel.sprite)
{
paddd(xmm3, xmmword[edx + 16 * 8]);
}
else
{
if(m_sel.ltf)
{
movdqa(xmm4, xmm3);
pshuflw(xmm4, xmm4, _MM_SHUFFLE(2, 2, 0, 0));
pshufhw(xmm4, xmm4, _MM_SHUFFLE(2, 2, 0, 0));
psrlw(xmm4, 1);
movdqa(xmmword[&m_env.temp.vf], xmm4);
}
}
movdqa(xmmword[&m_env.temp.s], xmm2);
movdqa(xmmword[&m_env.temp.t], xmm3);
}
else
{
// s = vt.xxxx() + m_env.d[skip].s;
// t = vt.yyyy() + m_env.d[skip].t;
// q = vt.zzzz() + m_env.d[skip].q;
movaps(xmm2, xmm4);
movaps(xmm3, xmm4);
shufps(xmm2, xmm2, _MM_SHUFFLE(0, 0, 0, 0));
shufps(xmm3, xmm3, _MM_SHUFFLE(1, 1, 1, 1));
shufps(xmm4, xmm4, _MM_SHUFFLE(2, 2, 2, 2));
addps(xmm2, xmmword[edx + 16 * 1]);
addps(xmm3, xmmword[edx + 16 * 2]);
addps(xmm4, xmmword[edx + 16 * 3]);
movaps(xmmword[&m_env.temp.s], xmm2);
movaps(xmmword[&m_env.temp.t], xmm3);
movaps(xmmword[&m_env.temp.q], xmm4);
rcpps(xmm4, xmm4);
mulps(xmm2, xmm4);
mulps(xmm3, xmm4);
}
}
if(!(m_sel.tfx == TFX_DECAL && m_sel.tcc))
{
if(m_sel.iip)
{
// GSVector4i vc = GSVector4i(v.c);
cvttps2dq(xmm6, xmmword[ebx]); // v.c
// vc = vc.upl16(vc.zwxy());
pshufd(xmm5, xmm6, _MM_SHUFFLE(1, 0, 3, 2));
punpcklwd(xmm6, xmm5);
// rb = vc.xxxx().add16(m_env.d[skip].rb);
// ga = vc.zzzz().add16(m_env.d[skip].ga);
pshufd(xmm5, xmm6, _MM_SHUFFLE(0, 0, 0, 0));
pshufd(xmm6, xmm6, _MM_SHUFFLE(2, 2, 2, 2));
paddw(xmm5, xmmword[edx + 16 * 4]);
paddw(xmm6, xmmword[edx + 16 * 5]);
movdqa(xmmword[&m_env.temp.rb], xmm5);
movdqa(xmmword[&m_env.temp.ga], xmm6);
}
else
{
if(m_sel.tfx == TFX_NONE)
{
movdqa(xmm5, xmmword[&m_env.c.rb]);
movdqa(xmm6, xmmword[&m_env.c.ga]);
}
}
}
}
}
void GSDrawScanlineCodeGenerator::Step()
{
// steps -= 4;
sub(ecx, 4);
// fza_offset++;
add(edi, 8);
if(!m_sel.sprite)
{
// z += m_env.d4.z;
if(m_sel.zb)
{
movaps(xmm0, xmmword[&m_env.temp.z]);
addps(xmm0, xmmword[&m_env.d4.z]);
movaps(xmmword[&m_env.temp.z], xmm0);
}
// f = f.add16(m_env.d4.f);
if(m_sel.fwrite && m_sel.fge)
{
movdqa(xmm1, xmmword[&m_env.temp.f]);
paddw(xmm1, xmmword[&m_env.d4.f]);
movdqa(xmmword[&m_env.temp.f], xmm1);
}
}
else
{
if(m_sel.ztest)
{
movdqa(xmm0, xmmword[&m_env.p.z]);
}
}
if(m_sel.fb)
{
if(m_sel.tfx != TFX_NONE)
{
if(m_sel.fst)
{
// GSVector4i st = m_env.d4.st;
// si += st.xxxx();
// if(!sprite) ti += st.yyyy();
movdqa(xmm4, xmmword[&m_env.d4.st]);
pshufd(xmm2, xmm4, _MM_SHUFFLE(0, 0, 0, 0));
paddd(xmm2, xmmword[&m_env.temp.s]);
movdqa(xmmword[&m_env.temp.s], xmm2);
if(!m_sel.sprite)
{
pshufd(xmm3, xmm4, _MM_SHUFFLE(1, 1, 1, 1));
paddd(xmm3, xmmword[&m_env.temp.t]);
movdqa(xmmword[&m_env.temp.t], xmm3);
}
else
{
movdqa(xmm3, xmmword[&m_env.temp.t]);
}
}
else
{
// GSVector4 stq = m_env.d4.stq;
// s += stq.xxxx();
// t += stq.yyyy();
// q += stq.zzzz();
movaps(xmm2, xmmword[&m_env.d4.stq]);
movaps(xmm3, xmm2);
movaps(xmm4, xmm2);
shufps(xmm2, xmm2, _MM_SHUFFLE(0, 0, 0, 0));
shufps(xmm3, xmm3, _MM_SHUFFLE(1, 1, 1, 1));
shufps(xmm4, xmm4, _MM_SHUFFLE(2, 2, 2, 2));
addps(xmm2, xmmword[&m_env.temp.s]);
addps(xmm3, xmmword[&m_env.temp.t]);
addps(xmm4, xmmword[&m_env.temp.q]);
movaps(xmmword[&m_env.temp.s], xmm2);
movaps(xmmword[&m_env.temp.t], xmm3);
movaps(xmmword[&m_env.temp.q], xmm4);
rcpps(xmm4, xmm4);
mulps(xmm2, xmm4);
mulps(xmm3, xmm4);
}
}
if(!(m_sel.tfx == TFX_DECAL && m_sel.tcc))
{
if(m_sel.iip)
{
// GSVector4i c = m_env.d4.c;
// rb = rb.add16(c.xxxx());
// ga = ga.add16(c.yyyy());
movdqa(xmm7, xmmword[&m_env.d4.c]);
pshufd(xmm5, xmm7, _MM_SHUFFLE(0, 0, 0, 0));
pshufd(xmm6, xmm7, _MM_SHUFFLE(1, 1, 1, 1));
paddw(xmm5, xmmword[&m_env.temp.rb]);
paddw(xmm6, xmmword[&m_env.temp.ga]);
movdqa(xmmword[&m_env.temp.rb], xmm5);
movdqa(xmmword[&m_env.temp.ga], xmm6);
}
else
{
if(m_sel.tfx == TFX_NONE)
{
movdqa(xmm5, xmmword[&m_env.c.rb]);
movdqa(xmm6, xmmword[&m_env.c.ga]);
}
}
}
}
// test = m_test[7 + (steps & (steps >> 31))];
mov(edx, ecx);
sar(edx, 31);
and(edx, ecx);
shl(edx, 4);
movdqa(xmm7, xmmword[edx + (size_t)&m_test[7]]);
}
