void FragmentProgramDecompiler::AddCodeCond(const std::string& dst, const std::string& src) { if (src0.exec_if_gr && src0.exec_if_lt && src0.exec_if_eq) { AddCode(dst + " = " + src + ";"); return; } if (!src0.exec_if_gr && !src0.exec_if_lt && !src0.exec_if_eq) { AddCode("//" + dst + " = " + src + ";"); return; } static const char f[4] = { 'x', 'y', 'z', 'w' }; std::string swizzle, cond; swizzle += f[src0.cond_swizzle_x]; swizzle += f[src0.cond_swizzle_y]; swizzle += f[src0.cond_swizzle_z]; swizzle += f[src0.cond_swizzle_w]; swizzle = swizzle == "xyzw" ? "" : "." + swizzle; if (src0.exec_if_gr && src0.exec_if_eq) cond = compareFunction(COMPARE::FUNCTION_SGE, AddCond() + swizzle, getFloatTypeName(4) + "(0., 0., 0., 0.)"); else if (src0.exec_if_lt && src0.exec_if_eq) cond = compareFunction(COMPARE::FUNCTION_SLE, AddCond() + swizzle, getFloatTypeName(4) + "(0., 0., 0., 0.)"); else if (src0.exec_if_gr && src0.exec_if_lt) cond = compareFunction(COMPARE::FUNCTION_SNE, AddCond() + swizzle, getFloatTypeName(4) + "(0., 0., 0., 0.)"); else if (src0.exec_if_gr) cond = compareFunction(COMPARE::FUNCTION_SGT, AddCond() + swizzle, getFloatTypeName(4) + "(0., 0., 0., 0.)"); else if (src0.exec_if_lt) cond = compareFunction(COMPARE::FUNCTION_SLT, AddCond() + swizzle, getFloatTypeName(4) + "(0., 0., 0., 0.)"); else //if(src0.exec_if_eq) cond = compareFunction(COMPARE::FUNCTION_SEQ, AddCond() + swizzle, getFloatTypeName(4) + "(0., 0., 0., 0.)"); ShaderVariable dst_var(dst); dst_var.symplify(); //const char *c_mask = f; if (dst_var.swizzles[0].length() == 1) { AddCode("if (" + cond + ".x) " + dst + " = " + src + ";"); } else { for (int i = 0; i < dst_var.swizzles[0].length(); ++i) { AddCode("if (" + cond + "." + f[i] + ") " + dst + "." + f[i] + " = " + src + "." + f[i] + ";"); } } }
bool FragmentProgramDecompiler::handle_scb(u32 opcode) { switch (opcode) { case RSX_FP_OPCODE_ADD: SetDst("($0 + $1)"); return true; case RSX_FP_OPCODE_COS: SetDst("cos($0.xxxx)"); return true; case RSX_FP_OPCODE_DIV: SetDst("($0 / $1.xxxx)"); return true; // Note: DIVSQ is not IEEE compliant. sqrt(0, 0) is 0 (Super Puzzle Fighter II Turbo HD Remix). // sqrt(x, 0) might be equal to some big value (in absolute) whose sign is sign(x) but it has to be proven. case RSX_FP_OPCODE_DIVSQ: SetDst("divsq_legacy($0, sqrt($1).xxxx)"); return true; case RSX_FP_OPCODE_DP2: SetDst(getFunction(FUNCTION::FUNCTION_DP2)); return true; case RSX_FP_OPCODE_DP3: SetDst(getFunction(FUNCTION::FUNCTION_DP3)); return true; case RSX_FP_OPCODE_DP4: SetDst(getFunction(FUNCTION::FUNCTION_DP4)); return true; case RSX_FP_OPCODE_DP2A: SetDst(getFunction(FUNCTION::FUNCTION_DP2A)); return true; case RSX_FP_OPCODE_DST: SetDst("vec4(distance($0, $1))"); return true; case RSX_FP_OPCODE_REFL: LOG_ERROR(RSX, "Unimplemented SCB instruction: REFL"); return true; // TODO: Is this in the right category? case RSX_FP_OPCODE_EX2: SetDst("exp2($0.xxxx)"); return true; case RSX_FP_OPCODE_FLR: SetDst("floor($0)"); return true; case RSX_FP_OPCODE_FRC: SetDst(getFunction(FUNCTION::FUNCTION_FRACT)); return true; case RSX_FP_OPCODE_LIT: SetDst(getFloatTypeName(4) + "(1.0, $0.x, ($0.x > 0.0 ? exp($0.w * log2($0.y)) : 0.0), 1.0)"); return true; case RSX_FP_OPCODE_LIF: SetDst(getFloatTypeName(4) + "(1.0, $0.y, ($0.y > 0 ? pow(2.0, $0.w) : 0.0), 1.0)"); return true; case RSX_FP_OPCODE_LRP: LOG_ERROR(RSX, "Unimplemented SCB instruction: LRP"); return true; // TODO: Is this in the right category? case RSX_FP_OPCODE_LG2: SetDst("log2($0.xxxx)"); return true; case RSX_FP_OPCODE_MAD: SetDst("($0 * $1 + $2)"); return true; case RSX_FP_OPCODE_MAX: SetDst("max($0, $1)"); return true; case RSX_FP_OPCODE_MIN: SetDst("min($0, $1)"); return true; case RSX_FP_OPCODE_MOV: SetDst("$0"); return true; case RSX_FP_OPCODE_MUL: SetDst("($0 * $1)"); return true; case RSX_FP_OPCODE_PK2: SetDst("packSnorm2x16($0)"); return true; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_PK4: SetDst("packSnorm4x8($0)"); return true; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_PK16: LOG_ERROR(RSX, "Unimplemented SCB instruction: PK16"); return true; case RSX_FP_OPCODE_PKB: LOG_ERROR(RSX, "Unimplemented SCB instruction: PKB"); return true; case RSX_FP_OPCODE_PKG: LOG_ERROR(RSX, "Unimplemented SCB instruction: PKG"); return true; case RSX_FP_OPCODE_SEQ: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SEQ, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SFL: SetDst(getFunction(FUNCTION::FUNCTION_SFL)); return true; case RSX_FP_OPCODE_SGE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGE, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SGT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGT, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SIN: SetDst("sin($0.xxxx)"); return true; case RSX_FP_OPCODE_SLE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLE, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SLT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLT, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SNE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SNE, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_STR: SetDst(getFunction(FUNCTION::FUNCTION_STR)); return true; } return false; }
/* This function (for internal use only) locates an element in an ** hash table that matches the given key. The hash for this key has ** already been computed and is passed as the 4th parameter. */ static fts2HashElem *findElementGivenHash( const fts2Hash *pH, /* The pH to be searched */ const void *pKey, /* The key we are searching for */ int nKey, int h /* The hash for this key. */ ){ fts2HashElem *elem; /* Used to loop thru the element list */ int count; /* Number of elements left to test */ int (*xCompare)(const void*,int,const void*,int); /* comparison function */ if( pH->ht ){ struct _fts2ht *pEntry = &pH->ht[h]; elem = pEntry->chain; count = pEntry->count; xCompare = compareFunction(pH->keyClass); while( count-- && elem ){ if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ return elem; } elem = elem->next; } } return 0; }
//Bubblesort for List //Input: CompareFunction with Atribute Details and Return //0 The element pointed by p1 goes before the element pointed by p2 //>0 The element pointed by p1 goes after the element pointed by p2 void bubbleSortList(int (*compareFunction) (Details *,Details *)) { Node * tmpAnkerEnde=NULL, * curNode; tmpAnkerEnde = ankerEnde; do{ //restarts from beginning curNode = ankerAnfang; //Moves element to ende while(curNode != tmpAnkerEnde) { if (compareFunction(curNode->nodeDetails , curNode->next->nodeDetails)) //compare elements { swapNodes(curNode, curNode->next); //swap element curNode = curNode->next; //Go to next element } else { curNode = curNode->next; //go to next element } } tmpAnkerEnde = curNode->prev; //set tmpAnkerEnde to last Moved Element so the list will be shorter }while(curNode->prev != NULL); }
bool FragmentProgramDecompiler::handle_scb(u32 opcode) { switch (opcode) { case RSX_FP_OPCODE_ADD: SetDst("($0 + $1)"); return true; case RSX_FP_OPCODE_COS: SetDst("cos($0.xxxx)"); return true; case RSX_FP_OPCODE_DIVSQ: SetDst("($0 / sqrt($1).xxxx)"); return true; case RSX_FP_OPCODE_DP2: SetDst(getFunction(FUNCTION::FUNCTION_DP2)); return true; case RSX_FP_OPCODE_DP3: SetDst(getFunction(FUNCTION::FUNCTION_DP3)); return true; case RSX_FP_OPCODE_DP4: SetDst(getFunction(FUNCTION::FUNCTION_DP4)); return true; case RSX_FP_OPCODE_DP2A: SetDst(getFunction(FUNCTION::FUNCTION_DP2A)); return true; case RSX_FP_OPCODE_DST: SetDst("vec4(distance($0, $1))"); return true; case RSX_FP_OPCODE_REFL: LOG_ERROR(RSX, "Unimplemented SCB instruction: REFL"); return true; // TODO: Is this in the right category? case RSX_FP_OPCODE_EX2: SetDst("exp2($0.xxxx)"); return true; case RSX_FP_OPCODE_FLR: SetDst("floor($0)"); return true; case RSX_FP_OPCODE_FRC: SetDst(getFunction(FUNCTION::FUNCTION_FRACT)); return true; case RSX_FP_OPCODE_LIT: SetDst(getFloatTypeName(4) + "(1.0, $0.x, ($0.x > 0.0 ? exp($0.w * log2($0.y)) : 0.0), 1.0)"); return true; case RSX_FP_OPCODE_LIF: SetDst(getFloatTypeName(4) + "(1.0, $0.y, ($0.y > 0 ? pow(2.0, $0.w) : 0.0), 1.0)"); return true; case RSX_FP_OPCODE_LRP: LOG_ERROR(RSX, "Unimplemented SCB instruction: LRP"); return true; // TODO: Is this in the right category? case RSX_FP_OPCODE_LG2: SetDst("log2($0.xxxx)"); return true; case RSX_FP_OPCODE_MAD: SetDst("($0 * $1 + $2)"); return true; case RSX_FP_OPCODE_MAX: SetDst("max($0, $1)"); return true; case RSX_FP_OPCODE_MIN: SetDst("min($0, $1)"); return true; case RSX_FP_OPCODE_MOV: SetDst("$0"); return true; case RSX_FP_OPCODE_MUL: SetDst("($0 * $1)"); return true; case RSX_FP_OPCODE_PK2: SetDst("packSnorm2x16($0)"); return true; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_PK4: SetDst("packSnorm4x8($0)"); return true; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_PK16: LOG_ERROR(RSX, "Unimplemented SCB instruction: PK16"); return true; case RSX_FP_OPCODE_PKB: LOG_ERROR(RSX, "Unimplemented SCB instruction: PKB"); return true; case RSX_FP_OPCODE_PKG: LOG_ERROR(RSX, "Unimplemented SCB instruction: PKG"); return true; case RSX_FP_OPCODE_SEQ: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SEQ, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SFL: SetDst(getFunction(FUNCTION::FUNCTION_SFL)); return true; case RSX_FP_OPCODE_SGE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGE, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SGT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGT, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SIN: SetDst("sin($0.xxxx)"); return true; case RSX_FP_OPCODE_SLE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLE, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SLT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLT, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_SNE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SNE, "$0", "$1") + ")"); return true; case RSX_FP_OPCODE_STR: SetDst(getFunction(FUNCTION::FUNCTION_STR)); return true; } return false; }
std::string VertexProgramDecompiler::Decompile() { for (unsigned i = 0; i < PF_PARAM_COUNT; i++) m_parr.params[i].clear(); m_instr_count = 0; for (int i = 0; i < m_max_instr_count; ++i) { m_instructions[i].reset(); } bool is_has_BRA = false; for (u32 i = 1; m_instr_count < m_max_instr_count; m_instr_count++) { m_cur_instr = &m_instructions[m_instr_count]; if (is_has_BRA) { d3.HEX = m_data[i]; i += 4; } else { d1.HEX = m_data[i++]; switch (d1.sca_opcode) { case 0x08: //BRA LOG_ERROR(RSX, "BRA found. Please report to RPCS3 team."); is_has_BRA = true; m_jump_lvls.clear(); d3.HEX = m_data[++i]; i += 4; break; case 0x09: //BRI d2.HEX = m_data[i++]; d3.HEX = m_data[i]; i += 2; m_jump_lvls.emplace(GetAddr()); break; default: d3.HEX = m_data[++i]; i += 2; break; } } if (d3.end) { m_instr_count++; if (i < m_data.size()) { LOG_ERROR(RSX, "Program end before buffer end."); } break; } } uint jump_position = 0; if (is_has_BRA || !m_jump_lvls.empty()) { m_cur_instr = &m_instructions[0]; AddCode("int jump_position = 0;"); AddCode("while (true)"); AddCode("{"); m_cur_instr->open_scopes++; AddCode(fmt::format("if (jump_position <= %u)", jump_position++)); AddCode("{"); m_cur_instr->open_scopes++; } for (u32 i = 0; i < m_instr_count; ++i) { m_cur_instr = &m_instructions[i]; d0.HEX = m_data[i * 4 + 0]; d1.HEX = m_data[i * 4 + 1]; d2.HEX = m_data[i * 4 + 2]; d3.HEX = m_data[i * 4 + 3]; src[0].src0l = d2.src0l; src[0].src0h = d1.src0h; src[1].src1 = d2.src1; src[2].src2l = d3.src2l; src[2].src2h = d2.src2h; if (i && (is_has_BRA || std::find(m_jump_lvls.begin(), m_jump_lvls.end(), i) != m_jump_lvls.end())) { m_cur_instr->close_scopes++; AddCode("}"); AddCode(""); AddCode(fmt::format("if (jump_position <= %u)", jump_position++)); AddCode("{"); m_cur_instr->open_scopes++; } if (!d1.sca_opcode && !d1.vec_opcode) { AddCode("//nop"); } switch (d1.sca_opcode) { case RSX_SCA_OPCODE_NOP: break; case RSX_SCA_OPCODE_MOV: SetDSTSca("$s"); break; case RSX_SCA_OPCODE_RCP: SetDSTSca("(1.0 / $s)"); break; case RSX_SCA_OPCODE_RCC: SetDSTSca("clamp(1.0 / $s, 5.42101e-20, 1.884467e19)"); break; case RSX_SCA_OPCODE_RSQ: SetDSTSca("(1.f / sqrt($s))"); break; case RSX_SCA_OPCODE_EXP: SetDSTSca("exp($s)"); break; case RSX_SCA_OPCODE_LOG: SetDSTSca("log($s)"); break; case RSX_SCA_OPCODE_LIT: SetDSTSca(getFloatTypeName(4) + "(1.0, $s.x, ($s.x > 0.0 ? exp($s.w * log2($s.y)) : 0.0), 1.0)"); break; case RSX_SCA_OPCODE_BRA: { AddCode("$if ($cond)"); AddCode("{"); m_cur_instr->open_scopes++; AddCode("jump_position = $a$am;"); AddCode("continue;"); m_cur_instr->close_scopes++; AddCode("}"); } break; case RSX_SCA_OPCODE_BRI: // works differently (BRI o[1].x(TR) L0;) { u32 jump_position = 1; if (is_has_BRA) { jump_position = GetAddr(); } else { u32 addr = GetAddr(); for (auto pos : m_jump_lvls) { if (addr == pos) break; ++jump_position; } } AddCode("$ifcond "); AddCode("{"); m_cur_instr->open_scopes++; AddCode(fmt::format("jump_position = %u;", jump_position)); AddCode("continue;"); m_cur_instr->close_scopes++; AddCode("}"); } break; case RSX_SCA_OPCODE_CAL: // works same as BRI AddCode("$ifcond $f(); //CAL"); break; case RSX_SCA_OPCODE_CLI: // works same as BRI AddCode("$ifcond $f(); //CLI"); break; case RSX_SCA_OPCODE_RET: // works like BRI but shorter (RET o[1].x(TR);) AddCode("$ifcond return;"); break; case RSX_SCA_OPCODE_LG2: SetDSTSca("log2($s)"); break; case RSX_SCA_OPCODE_EX2: SetDSTSca("exp2($s)"); break; case RSX_SCA_OPCODE_SIN: SetDSTSca("sin($s)"); break; case RSX_SCA_OPCODE_COS: SetDSTSca("cos($s)"); break; case RSX_SCA_OPCODE_BRB: // works differently (BRB o[1].x !b0, L0;) LOG_ERROR(RSX, "Unimplemented sca_opcode BRB"); break; case RSX_SCA_OPCODE_CLB: break; // works same as BRB LOG_ERROR(RSX, "Unimplemented sca_opcode CLB"); break; case RSX_SCA_OPCODE_PSH: break; // works differently (PSH o[1].x A0;) LOG_ERROR(RSX, "Unimplemented sca_opcode PSH"); break; case RSX_SCA_OPCODE_POP: break; // works differently (POP o[1].x;) LOG_ERROR(RSX, "Unimplemented sca_opcode POP"); break; default: AddCode(fmt::format("//Unknown vp sca_opcode 0x%x", u32{ d1.sca_opcode })); LOG_ERROR(RSX, "Unknown vp sca_opcode 0x%x", u32{ d1.sca_opcode }); Emu.Pause(); break; } switch (d1.vec_opcode) { case RSX_VEC_OPCODE_NOP: break; case RSX_VEC_OPCODE_MOV: SetDSTVec("$0"); break; case RSX_VEC_OPCODE_MUL: SetDSTVec("($0 * $1)"); break; case RSX_VEC_OPCODE_ADD: SetDSTVec("($0 + $2)"); break; case RSX_VEC_OPCODE_MAD: SetDSTVec("($0 * $1 + $2)"); break; case RSX_VEC_OPCODE_DP3: SetDSTVec(getFunction(FUNCTION::FUNCTION_DP3)); break; case RSX_VEC_OPCODE_DPH: SetDSTVec(getFunction(FUNCTION::FUNCTION_DPH)); break; case RSX_VEC_OPCODE_DP4: SetDSTVec(getFunction(FUNCTION::FUNCTION_DP4)); break; case RSX_VEC_OPCODE_DST: SetDSTVec("vec4(distance($0, $1))"); break; case RSX_VEC_OPCODE_MIN: SetDSTVec("min($0, $1)"); break; case RSX_VEC_OPCODE_MAX: SetDSTVec("max($0, $1)"); break; case RSX_VEC_OPCODE_SLT: SetDSTVec(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLT, "$0", "$1") + ")"); break; case RSX_VEC_OPCODE_SGE: SetDSTVec(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGE, "$0", "$1") + ")"); break; // Note: It looks like ARL opcode ignore input/output swizzle mask (SH3) case RSX_VEC_OPCODE_ARL: AddCode("$ifcond $awm = " + getIntTypeName(4) + "($0);"); break; case RSX_VEC_OPCODE_FRC: SetDSTVec(getFunction(FUNCTION::FUNCTION_FRACT)); break; case RSX_VEC_OPCODE_FLR: SetDSTVec("floor($0)"); break; case RSX_VEC_OPCODE_SEQ: SetDSTVec(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SEQ, "$0", "$1") + ")"); break; case RSX_VEC_OPCODE_SFL: SetDSTVec(getFunction(FUNCTION::FUNCTION_SFL)); break; case RSX_VEC_OPCODE_SGT: SetDSTVec(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGT, "$0", "$1") + ")"); break; case RSX_VEC_OPCODE_SLE: SetDSTVec(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLE, "$0", "$1") + ")"); break; case RSX_VEC_OPCODE_SNE: SetDSTVec(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SNE, "$0", "$1") + ")"); break; case RSX_VEC_OPCODE_STR: SetDSTVec(getFunction(FUNCTION::FUNCTION_STR)); break; case RSX_VEC_OPCODE_SSG: SetDSTVec("sign($0)"); break; case RSX_VEC_OPCODE_TXL: SetDSTVec("texture($t, $0.xy)"); break; default: AddCode(fmt::format("//Unknown vp opcode 0x%x", u32{ d1.vec_opcode })); LOG_ERROR(RSX, "Unknown vp opcode 0x%x", u32{ d1.vec_opcode }); Emu.Pause(); break; } } if (is_has_BRA || !m_jump_lvls.empty()) { m_cur_instr = &m_instructions[m_instr_count - 1]; m_cur_instr->close_scopes++; AddCode("}"); AddCode("break;"); m_cur_instr->close_scopes++; AddCode("}"); } std::string result = BuildCode(); m_jump_lvls.clear(); m_body.clear(); if (m_funcs.size() > 2) { m_funcs.erase(m_funcs.begin() + 2, m_funcs.end()); } return result; }
void VertexProgramDecompiler::AddCodeCond(const std::string& dst, const std::string& src) { enum { lt = 0x1, eq = 0x2, gt = 0x4, }; if (!d0.cond_test_enable || d0.cond == (lt | gt | eq)) { AddCode(dst + " = " + src + ";"); return; } if (d0.cond == 0) { AddCode("//" + dst + " = " + src + ";"); return; } static const COMPARE cond_string_table[(lt | gt | eq) + 1] = { COMPARE::FUNCTION_SLT, // "error" COMPARE::FUNCTION_SLT, COMPARE::FUNCTION_SEQ, COMPARE::FUNCTION_SLE, COMPARE::FUNCTION_SGT, COMPARE::FUNCTION_SNE, COMPARE::FUNCTION_SGE, }; static const char f[4] = { 'x', 'y', 'z', 'w' }; std::string swizzle; swizzle += f[d0.mask_x]; swizzle += f[d0.mask_y]; swizzle += f[d0.mask_z]; swizzle += f[d0.mask_w]; swizzle = swizzle == "xyzw" ? "" : "." + swizzle; std::string cond = compareFunction(cond_string_table[d0.cond], "cc" + std::to_string(d0.cond_reg_sel_1) + swizzle.c_str(), getFloatTypeName(4) + "(0., 0., 0., 0.)"); ShaderVariable dst_var(dst); dst_var.symplify(); //const char *c_mask = f; if (dst_var.swizzles[0].length() == 1) { AddCode("if (" + cond + ".x) " + dst + " = " + src + ";"); } else { for (int i = 0; i < dst_var.swizzles[0].length(); ++i) { AddCode("if (" + cond + "." + f[i] + ") " + dst + "." + f[i] + " = " + src + "." + f[i] + ";"); } } }
/*********************************************************************** * * Method : d_avlTreeRemove * Algorithm : * 1st : find node to be deleted by a iterative tree walk. * 2nd : if found then remove node. * 3rd : rebalance tree. * Returns data or zero if not found ***********************************************************************/ c_voidp d_avlTreeRemove ( d_avlNode * rootNodePntr, c_voidp data, int (* compareFunction)() ) { d_avlNode * nodeplace; d_avlNode * stack[D_AVLTREE_MAXHEIGHT]; d_avlNode ** stack_ptr; d_avlNode * nodeplace_to_delete; d_avlNode node_to_delete; d_avlNode node; d_avlNode ** stack_ptr_to_delete; c_long stack_count; int comparison; c_voidp removedData; assert(rootNodePntr != NULL); assert(*rootNodePntr != NULL); assert(data != NULL); assert(compareFunction != (int(*)())NULL); stack_ptr = &stack[0]; node_to_delete = NULL; stack_count = 0; nodeplace = rootNodePntr; for (;;) { node = *nodeplace; *stack_ptr = nodeplace; stack_ptr++; stack_count++; if (node == NULL) { return NULL; } comparison = compareFunction(data, node->data); if (comparison == 0) { node_to_delete = node; break; } if (comparison < 0) { nodeplace = &node->left; } else { nodeplace = &node->right; } } assert(node_to_delete != NULL); nodeplace_to_delete = nodeplace; if (node_to_delete->left == NULL) { *nodeplace_to_delete = node_to_delete->right; stack_ptr--; stack_count--; } else { stack_ptr_to_delete = stack_ptr; nodeplace = &node_to_delete->left; for (;;) { node = *nodeplace; if (node->right == NULL) { break; } *stack_ptr = nodeplace; stack_ptr++; stack_count++; nodeplace = &node->right; } *nodeplace = node->left; node->left = node_to_delete->left; node->right = node_to_delete->right; node->height = node_to_delete->height; *nodeplace_to_delete = node; *stack_ptr_to_delete = &node->left; } d_avlTreeRebalance(stack_ptr, stack_count); removedData = node_to_delete->data; avlTreeFreeNode(node_to_delete); return removedData; }
/////////////////////////////////////////////////////////////////////////////// // Prints convex hull of a set of n points. void computeConvexHull(const std::vector<Point*>& pointArray, std::vector<Point*>& curve, const bool bVerbose) { if(bVerbose) { fprintf(stdout, "computeConvexHull: nbPts: %ld\n", pointArray.size()); } curve.resize(0); if(pointArray.size() < 3) { return; } std::vector<Point*> points; points.resize(pointArray.size()); for(size_t i=0; i<points.size(); i++) { points[i] = pointArray[i]; } const size_t n = points.size(); // Find the bottommost point size_t min = 0; Coord ymin = points[min]->y(); Coord xmin = points[min]->x(); for(size_t i=1; i<n; i++) { const Coord x = points[i]->x(); const Coord y = points[i]->y(); // Pick the bottom-most or chose the left most point in case of tie if ((y<ymin) || (isEqual(y,ymin) && x<xmin)) { min = i; xmin = x; ymin = y; } } // Place the bottom-most point at first position //std::swap(points[0], points[min]); if(min != 0) { Point* p = points[0]; points[0] = points[min]; points[min] = p; } if(0 && bVerbose) { fprintf(stdout, "pivot point: %s, at pos:%ld\n", points[0]->toString().c_str(), min); } // Sort n-1 points with respect to the first point. A point p1 comes // before p2 in sorted ouput if p2 has larger polar angle (in // counterclockwise direction) than p1 // qsort(&points[1], n-1, sizeof(Point), compare); ComparePoints<Point*> compareFunction(points[0]); // Note: for some unknown reason, the std::sort does not work on apple c++ compiler. // the swap of pointers is not working properly!!! // std::sort(points.begin()+1, points.end(), compareFunction); // BubbleSort(points, 1, compareFunction); QuickSort(points, 1, points.size()-1, compareFunction); // print the point array if(0 && bVerbose) { fprintf(stdout, "** List of sorted points\n"); for(size_t i=0; i<n; i++) { if(points[i]) { fprintf(stdout, "[%03ld]: %s \n", i, points[i]->toString().c_str()); } else { fprintf(stdout, "[%ld] null\n", i); } } fprintf(stdout, "\n\n"); } // Create an empty stack and push first three points to it. std::stack<Point*> stack; stack.push(points[0]); stack.push(points[1]); stack.push(points[2]); // Process remaining n-3 points for(size_t i=3; i<n; i++) { // Keep removing top while the angle formed by points next-to-top, // top, and points[i] makes a non-left turn while(stack.size()>1 && ComputePointOrientation(nextToTop(stack), stack.top(), points[i]) != PointOrientationConterClockWise) { stack.pop(); } stack.push(points[i]); } // collect the curve curve.resize(0); while (!stack.empty()) { curve.push_back(stack.top()); stack.pop(); } }
void ADT::search (Node* node, const ADTPoint& targetPoint, int& index) { if (node != NULL) { /*if (targetPoint.idx == 231) { cout << "alibaba" << endl; //exit(-2); }*/ // check whether the point is inside the element if (!node->isEmpty && node->p->idx!=-1 && doCubesOverlap (node, targetPoint) && compareFunction (node, targetPoint) ) { if (searchForNIntersections) { ++nIntersections; ids.push_back (node->p->idx); addresses.push_back (node); searchChildren (node, targetPoint); if (!searchStack.empty()) { Node* last = searchStack.back(); searchStack.back() = NULL; searchStack.pop_back(); search (last, targetPoint, index); } } else { fill (searchStack.begin(), searchStack.end(), nullptr); searchStack.clear(); index = node->p->idx; addresses.push_back (node); if (node != root) { node = NULL; } } } else { searchChildren (node, targetPoint); if (!searchStack.empty()) { Node* last = searchStack.back(); searchStack.back() = NULL; searchStack.pop_back(); search (last, targetPoint, index); } } } }
std::string FragmentProgramDecompiler::Decompile() { auto data = vm::ps3::ptr<u32>::make(m_addr); m_size = 0; m_location = 0; m_loop_count = 0; m_code_level = 1; enum { FORCE_NONE, FORCE_SCT, FORCE_SCB, }; int forced_unit = FORCE_NONE; while (true) { for (auto finded = std::find(m_end_offsets.begin(), m_end_offsets.end(), m_size); finded != m_end_offsets.end(); finded = std::find(m_end_offsets.begin(), m_end_offsets.end(), m_size)) { m_end_offsets.erase(finded); m_code_level--; AddCode("}"); m_loop_count--; } for (auto finded = std::find(m_else_offsets.begin(), m_else_offsets.end(), m_size); finded != m_else_offsets.end(); finded = std::find(m_else_offsets.begin(), m_else_offsets.end(), m_size)) { m_else_offsets.erase(finded); m_code_level--; AddCode("}"); AddCode("else"); AddCode("{"); m_code_level++; } dst.HEX = GetData(data[0]); src0.HEX = GetData(data[1]); src1.HEX = GetData(data[2]); src2.HEX = GetData(data[3]); m_offset = 4 * sizeof(u32); const u32 opcode = dst.opcode | (src1.opcode_is_branch << 6); auto SCT = [&]() { switch (opcode) { case RSX_FP_OPCODE_ADD: SetDst("($0 + $1)"); break; case RSX_FP_OPCODE_DIV: SetDst("($0 / $1)"); break; case RSX_FP_OPCODE_DIVSQ: SetDst("($0 / sqrt($1).xxxx)"); break; case RSX_FP_OPCODE_DP2: SetDst(getFunction(FUNCTION::FUNCTION_DP2)); break; case RSX_FP_OPCODE_DP3: SetDst(getFunction(FUNCTION::FUNCTION_DP3)); break; case RSX_FP_OPCODE_DP4: SetDst(getFunction(FUNCTION::FUNCTION_DP4)); break; case RSX_FP_OPCODE_DP2A: SetDst(getFunction(FUNCTION::FUNCTION_DP2A)); break; case RSX_FP_OPCODE_MAD: SetDst("($0 * $1 + $2)"); break; case RSX_FP_OPCODE_MAX: SetDst("max($0, $1)"); break; case RSX_FP_OPCODE_MIN: SetDst("min($0, $1)"); break; case RSX_FP_OPCODE_MOV: SetDst("$0"); break; case RSX_FP_OPCODE_MUL: SetDst("($0 * $1)"); break; case RSX_FP_OPCODE_RCP: SetDst("1.0 / $0"); break; case RSX_FP_OPCODE_RSQ: SetDst("1.f / sqrt($0)"); break; case RSX_FP_OPCODE_SEQ: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SEQ, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SFL: SetDst(getFunction(FUNCTION::FUNCTION_SFL)); break; case RSX_FP_OPCODE_SGE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGE, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SGT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGT, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SLE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLE, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SLT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLT, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SNE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SNE, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_STR: SetDst(getFunction(FUNCTION::FUNCTION_STR)); break; default: return false; } return true; }; auto SCB = [&]() { switch (opcode) { case RSX_FP_OPCODE_ADD: SetDst("($0 + $1)"); break; case RSX_FP_OPCODE_COS: SetDst("cos($0.xxxx)"); break; case RSX_FP_OPCODE_DP2: SetDst(getFunction(FUNCTION::FUNCTION_DP2)); break; case RSX_FP_OPCODE_DP3: SetDst(getFunction(FUNCTION::FUNCTION_DP3)); break; case RSX_FP_OPCODE_DP4: SetDst(getFunction(FUNCTION::FUNCTION_DP4)); break; case RSX_FP_OPCODE_DP2A: SetDst(getFunction(FUNCTION::FUNCTION_DP2A)); break; case RSX_FP_OPCODE_DST: SetDst("vec4(distance($0, $1))"); break; case RSX_FP_OPCODE_REFL: LOG_ERROR(RSX, "Unimplemented SCB instruction: REFL"); break; // TODO: Is this in the right category? case RSX_FP_OPCODE_EX2: SetDst("exp2($0.xxxx)"); break; case RSX_FP_OPCODE_FLR: SetDst("floor($0)"); break; case RSX_FP_OPCODE_FRC: SetDst(getFunction(FUNCTION::FUNCTION_FRACT)); break; case RSX_FP_OPCODE_LIT: SetDst(getFloatTypeName(4) + "(1.0, $0.x, ($0.x > 0.0 ? exp($0.w * log2($0.y)) : 0.0), 1.0)"); break; case RSX_FP_OPCODE_LIF: SetDst(getFloatTypeName(4) + "(1.0, $0.y, ($0.y > 0 ? pow(2.0, $0.w) : 0.0), 1.0)"); break; case RSX_FP_OPCODE_LRP: LOG_ERROR(RSX, "Unimplemented SCB instruction: LRP"); break; // TODO: Is this in the right category? case RSX_FP_OPCODE_LG2: SetDst("log2($0.xxxx)"); break; case RSX_FP_OPCODE_MAD: SetDst("($0 * $1 + $2)"); break; case RSX_FP_OPCODE_MAX: SetDst("max($0, $1)"); break; case RSX_FP_OPCODE_MIN: SetDst("min($0, $1)"); break; case RSX_FP_OPCODE_MOV: SetDst("$0"); break; case RSX_FP_OPCODE_MUL: SetDst("($0 * $1)"); break; case RSX_FP_OPCODE_PK2: SetDst("packSnorm2x16($0)"); break; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_PK4: SetDst("packSnorm4x8($0)"); break; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_PK16: LOG_ERROR(RSX, "Unimplemented SCB instruction: PK16"); break; case RSX_FP_OPCODE_PKB: LOG_ERROR(RSX, "Unimplemented SCB instruction: PKB"); break; case RSX_FP_OPCODE_PKG: LOG_ERROR(RSX, "Unimplemented SCB instruction: PKG"); break; case RSX_FP_OPCODE_SEQ: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SEQ, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SFL: SetDst(getFunction(FUNCTION::FUNCTION_SFL)); break; case RSX_FP_OPCODE_SGE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGE, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SGT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SGT, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SIN: SetDst("sin($0.xxxx)"); break; case RSX_FP_OPCODE_SLE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLE, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SLT: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SLT, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_SNE: SetDst(getFloatTypeName(4) + "(" + compareFunction(COMPARE::FUNCTION_SNE, "$0", "$1") + ")"); break; case RSX_FP_OPCODE_STR: SetDst(getFunction(FUNCTION::FUNCTION_STR)); break; default: return false; } return true; }; auto TEX_SRB = [&]() { switch (opcode) { case RSX_FP_OPCODE_DDX: SetDst(getFunction(FUNCTION::FUNCTION_DFDX)); break; case RSX_FP_OPCODE_DDY: SetDst(getFunction(FUNCTION::FUNCTION_DFDY)); break; case RSX_FP_OPCODE_NRM: SetDst("normalize($0)"); break; case RSX_FP_OPCODE_BEM: LOG_ERROR(RSX, "Unimplemented TEX_SRB instruction: BEM"); break; case RSX_FP_OPCODE_TEX: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE)); break; case RSX_FP_OPCODE_TEXBEM: SetDst("texture($t, $0.xy, $1.x)"); break; case RSX_FP_OPCODE_TXP: SetDst("textureProj($t, $0.xyz, $1.x)"); break; //TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478) and The Simpsons Arcade Game (NPUB30563)) case RSX_FP_OPCODE_TXPBEM: SetDst("textureProj($t, $0.xyz, $1.x)"); break; case RSX_FP_OPCODE_TXD: LOG_ERROR(RSX, "Unimplemented TEX_SRB instruction: TXD"); break; case RSX_FP_OPCODE_TXB: SetDst("texture($t, $0.xy, $1.x)"); break; case RSX_FP_OPCODE_TXL: SetDst("textureLod($t, $0.xy, $1.x)"); break; case RSX_FP_OPCODE_UP2: SetDst("unpackSnorm2x16($0)"); break; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_UP4: SetDst("unpackSnorm4x8($0)"); break; // TODO: More testing (Sonic The Hedgehog (NPUB-30442/NPEB-00478)) case RSX_FP_OPCODE_UP16: LOG_ERROR(RSX, "Unimplemented TEX_SRB instruction: UP16"); break; case RSX_FP_OPCODE_UPB: LOG_ERROR(RSX, "Unimplemented TEX_SRB instruction: UPB"); break; case RSX_FP_OPCODE_UPG: LOG_ERROR(RSX, "Unimplemented TEX_SRB instruction: UPG"); break; default: return false; } return true; }; auto SIP = [&]() { switch (opcode) { case RSX_FP_OPCODE_BRK: SetDst("break"); break; case RSX_FP_OPCODE_CAL: LOG_ERROR(RSX, "Unimplemented SIP instruction: CAL"); break; case RSX_FP_OPCODE_FENCT: forced_unit = FORCE_SCT; break; case RSX_FP_OPCODE_FENCB: forced_unit = FORCE_SCB; break; case RSX_FP_OPCODE_IFE: AddCode("if($cond)"); if (src2.end_offset != src1.else_offset) m_else_offsets.push_back(src1.else_offset << 2); m_end_offsets.push_back(src2.end_offset << 2); AddCode("{"); m_code_level++; break; case RSX_FP_OPCODE_LOOP: if (!src0.exec_if_eq && !src0.exec_if_gr && !src0.exec_if_lt) { AddCode(fmt::Format("$ifcond for(int i%u = %u; i%u < %u; i%u += %u) {} //-> %u //LOOP", m_loop_count, src1.init_counter, m_loop_count, src1.end_counter, m_loop_count, src1.increment, src2.end_offset)); } else { AddCode(fmt::Format("$ifcond for(int i%u = %u; i%u < %u; i%u += %u) //LOOP", m_loop_count, src1.init_counter, m_loop_count, src1.end_counter, m_loop_count, src1.increment)); m_loop_count++; m_end_offsets.push_back(src2.end_offset << 2); AddCode("{"); m_code_level++; } break; case RSX_FP_OPCODE_REP: if (!src0.exec_if_eq && !src0.exec_if_gr && !src0.exec_if_lt) { AddCode(fmt::Format("$ifcond for(int i%u = %u; i%u < %u; i%u += %u) {} //-> %u //REP", m_loop_count, src1.init_counter, m_loop_count, src1.end_counter, m_loop_count, src1.increment, src2.end_offset)); } else { AddCode(fmt::Format("if($cond) for(int i%u = %u; i%u < %u; i%u += %u) //REP", m_loop_count, src1.init_counter, m_loop_count, src1.end_counter, m_loop_count, src1.increment)); m_loop_count++; m_end_offsets.push_back(src2.end_offset << 2); AddCode("{"); m_code_level++; } break; case RSX_FP_OPCODE_RET: SetDst("return"); break; default: return false; } return true; }; switch (opcode) { case RSX_FP_OPCODE_NOP: break; case RSX_FP_OPCODE_KIL: SetDst("discard", false); break; default: if (forced_unit == FORCE_NONE) { if (SIP()) break; if (SCT()) break; if (TEX_SRB()) break; if (SCB()) break; } else if (forced_unit == FORCE_SCT) { forced_unit = FORCE_NONE; if (SCT()) break; } else if (forced_unit == FORCE_SCB) { forced_unit = FORCE_NONE; if (SCB()) break; } LOG_ERROR(RSX, "Unknown/illegal instruction: 0x%x (forced unit %d)", opcode, forced_unit); break; } m_size += m_offset; if (dst.end) break; assert(m_offset % sizeof(u32) == 0); data += m_offset / sizeof(u32); } // flush m_code_level m_code_level = 1; std::string m_shader = BuildCode(); main.clear(); // m_parr.params.clear(); return m_shader; }