void Neuralnet::start(QString str) { str.replace(QString(" "),QString("")); STD(str); layoutNet1(); layoutNet2(); layoutNet3(); qDebug()<<str; qDebug()<<p[19+number1+number2]<<"|"<<p[19+number1+number2+1]; if(p[19+number1+number2]<p[19+number1+number2+1]) { if(str[0]=='1') { if((p[19+number1+number2+1]-p[19+number1+number2])>to) { to = p[19+number1+number2+1]-p[19+number1+number2]; } qDebug()<<"+"; i++; }else{ qDebug()<<"-"; i--; } }else{ if(str[0]=='1') { qDebug()<<"-"; i--; }else{ if((p[19+number1+number2]-p[19+number1+number2+1])>to) { to = p[19+number1+number2]-p[19+number1+number2+1]; } qDebug()<<"+"; i++; } } }
void OdGiWorldGeometryDumper::ray(const OdGePoint3d&, const OdGePoint3d&) { m_os << " " << "ray()" << STD(endl); }
static void execute(MVM_VirtualMachine *mvm, Function *func, MVM_Byte *code, int code_size) { int base; MVM_Executable *exe; int pc; //MVM_Value ret; pc = mvm->pc; exe = mvm->current_executable; while (pc < code_size) { /*printf("%s sp(%d)\t\n", mvm_opcode_info[code[pc]].mnemonic, mvm->stack.stack_pointer);*/ switch (code[pc]) { case MVM_PUSH_INT_1BYTE: STI_WRITE(mvm, 0, code[pc+1]); //printf("int byte %d\n",code[pc+1]); mvm->stack.stack_pointer++; pc += 2; break; case MVM_PUSH_INT_2BYTE: STI_WRITE(mvm, 0, GET_2BYTE_INT(&code[pc+1])); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_INT: STI_WRITE(mvm, 0, exe->constant_pool[GET_2BYTE_INT(&code[pc+1])].u.c_integer); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_DOUBLE_0: STD_WRITE(mvm, 0, 0.0); mvm->stack.stack_pointer++; pc++; break; case MVM_PUSH_DOUBLE_1: STD_WRITE(mvm, 0, 1.0); mvm->stack.stack_pointer++; pc++; break; case MVM_PUSH_DOUBLE: STD_WRITE(mvm, 0, exe->constant_pool[GET_2BYTE_INT(&code[pc+1])].u.c_decimal); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STRING: STO_WRITE(mvm, 0, mvm_literal_to_mvm_string_i(mvm, exe->constant_pool [GET_2BYTE_INT(&code [pc+1])] .u.c_string)); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_NULL: STO_WRITE(mvm, 0, NULL); mvm->stack.stack_pointer++; pc++; break; case MVM_PUSH_STACK_INT: STI_WRITE(mvm, 0, STI_I(mvm, base + GET_2BYTE_INT(&code[pc+1]))); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STACK_DOUBLE: STD_WRITE(mvm, 0, STD_I(mvm, base + GET_2BYTE_INT(&code[pc+1]))); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STACK_OBJECT: STO_WRITE(mvm, 0, STO_I(mvm, base + GET_2BYTE_INT(&code[pc+1]))); mvm->stack.stack_pointer++; pc += 3; break; case MVM_POP_STACK_INT: STI_WRITE_I(mvm, base + GET_2BYTE_INT(&code[pc+1]), STI(mvm, -1)); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STACK_DOUBLE: STD_WRITE_I(mvm, base + GET_2BYTE_INT(&code[pc+1]), STD(mvm, -1)); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STACK_OBJECT: STO_WRITE_I(mvm, base + GET_2BYTE_INT(&code[pc+1]), STO(mvm, -1)); mvm->stack.stack_pointer--; pc += 3; break; case MVM_PUSH_STATIC_INT: STI_WRITE(mvm, 0, mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])] .int_value); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STATIC_DOUBLE: STD_WRITE(mvm, 0, mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])] .double_value); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STATIC_OBJECT: STO_WRITE(mvm, 0,mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])].object); mvm->stack.stack_pointer++; pc += 3; break; case MVM_POP_STATIC_INT: mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])].int_value = STI(mvm, -1); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STATIC_DOUBLE: mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])] .double_value = STD(mvm, -1); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STATIC_OBJECT: mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])].object = STO(mvm, -1); mvm->stack.stack_pointer--; pc += 3; break; case MVM_PUSH_ARRAY_INT: { MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); int int_value; restore_pc(mvm, exe, func, pc); int_value = MVM_array_get_int(mvm, array, index); STI_WRITE(mvm, -2, int_value); mvm->stack.stack_pointer--; pc++; break; } case MVM_PUSH_ARRAY_DOUBLE: { MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); double double_value; restore_pc(mvm, exe, func, pc); double_value = MVM_array_get_double(mvm, array, index); STD_WRITE(mvm, -2, double_value); mvm->stack.stack_pointer--; pc++; break; } case MVM_PUSH_ARRAY_OBJECT: { MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); MVM_Object *object; restore_pc(mvm, exe, func, pc); object = MVM_array_get_object(mvm, array, index); STO_WRITE(mvm, -2, object); mvm->stack.stack_pointer--; pc++; break; } case MVM_POP_ARRAY_INT: { int value = STI(mvm, -3); MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); restore_pc(mvm, exe, func, pc); MVM_array_set_int(mvm, array, index, value); mvm->stack.stack_pointer -= 3; pc++; break; } case MVM_POP_ARRAY_DOUBLE: { double value = STD(mvm, -3); MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); restore_pc(mvm, exe, func, pc); MVM_array_set_double(mvm, array, index, value); mvm->stack.stack_pointer -= 3; pc++; break; } case MVM_POP_ARRAY_OBJECT: { MVM_Object *value = STO(mvm, -3); MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); restore_pc(mvm, exe, func, pc); MVM_array_set_object(mvm, array, index, value); mvm->stack.stack_pointer -= 3; pc++; break; } case MVM_PUSH_FIELD_INT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); STI_WRITE(mvm, -1, obj->u.class_object.field[index].int_value); pc += 3; break; } case MVM_PUSH_FIELD_DOUBLE: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); STD_WRITE(mvm, -1, obj->u.class_object.field[index].double_value); pc += 3; break; } case MVM_PUSH_FIELD_OBJECT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); STO_WRITE(mvm, -1, obj->u.class_object.field[index].object); pc += 3; break; } case MVM_POP_FIELD_INT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); obj->u.class_object.field[index].int_value = STI(mvm, -2); mvm->stack.stack_pointer -= 2; pc += 3; break; } case MVM_POP_FIELD_DOUBLE: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); obj->u.class_object.field[index].double_value = STD(mvm, -2); mvm->stack.stack_pointer -= 2; pc += 3; break; } case MVM_POP_FIELD_OBJECT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); obj->u.class_object.field[index].object = STO(mvm, -2); mvm->stack.stack_pointer -= 2; pc += 3; break; } case MVM_ADD_INT: STI(mvm, -2) = STI(mvm, -2) + STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_ADD_DOUBLE: STD(mvm, -2) = STD(mvm, -2) + STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_ADD_STRING: STO(mvm, -2) = chain_string(mvm, STO(mvm, -2), STO(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_SUB_INT: STI(mvm, -2) = STI(mvm, -2) - STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_SUB_DOUBLE: STD(mvm, -2) = STD(mvm, -2) - STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MUL_INT: STI(mvm, -2) = STI(mvm, -2) * STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MUL_DOUBLE: STD(mvm, -2) = STD(mvm, -2) * STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_DIV_INT: if (STI(mvm, -1) == 0) { //mvm_error(exe, func, pc, DIVISION_BY_ZERO_ERR, // MESSAGE_ARGUMENT_END); } STI(mvm, -2) = STI(mvm, -2) / STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_DIV_DOUBLE: STD(mvm, -2) = STD(mvm, -2) / STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MOD_INT: STI(mvm, -2) = STI(mvm, -2) % STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MOD_DOUBLE: STD(mvm, -2) = fmod(STD(mvm, -2), STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_MINUS_INT: STI(mvm, -1) = -STI(mvm, -1); pc++; break; case MVM_MINUS_DOUBLE: STD(mvm, -1) = -STD(mvm, -1); pc++; break; case MVM_INCREMENT: STI(mvm, -1)++; pc++; break; case MVM_DECREMENT: STI(mvm, -1)--; pc++; break; case MVM_CAST_INT_TO_DOUBLE: STD(mvm, -1) = (double)STI(mvm, -1); pc++; break; case MVM_CAST_DOUBLE_TO_INT: STI(mvm, -1) = (int)STD(mvm, -1); pc++; break; case MVM_CAST_BOOLEAN_TO_STRING: if (STI(mvm, -1)) { STO_WRITE(mvm, -1, mvm_literal_to_mvm_string_i(mvm, TRUE_STRING)); } else { STO_WRITE(mvm, -1, mvm_literal_to_mvm_string_i(mvm, FALSE_STRING)); } pc++; break; case MVM_CAST_INT_TO_STRING: { char buf[LINE_BUF_SIZE]; MVM_Char *str; sprintf(buf, "%d", STI(mvm, -1)); restore_pc(mvm, exe, func, pc); str = str_alloc(buf); STO_WRITE(mvm, -1, mvm_create_mvm_string_i(mvm, str)); pc++; break; } case MVM_CAST_DOUBLE_TO_STRING: { char buf[LINE_BUF_SIZE]; MVM_Char *str; sprintf(buf, "%f", STD(mvm, -1)); restore_pc(mvm, exe, func, pc); str = str_alloc(buf); STO_WRITE(mvm, -1, mvm_create_mvm_string_i(mvm, str)); pc++; break; } case MVM_EQ_INT: STI(mvm, -2) = (STI(mvm, -2) == STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_EQ_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) == STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_EQ_OBJECT: STI_WRITE(mvm, -2, STO(mvm, -2) == STO(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_EQ_STRING: STI_WRITE(mvm, -2, !strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string)); mvm->stack.stack_pointer--; pc++; break; case MVM_GT_INT: STI(mvm, -2) = (STI(mvm, -2) > STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GT_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) > STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GT_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) > 0); mvm->stack.stack_pointer--; pc++; break; case MVM_GE_INT: STI(mvm, -2) = (STI(mvm, -2) >= STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GE_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) >= STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GE_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) >= 0); mvm->stack.stack_pointer--; pc++; break; case MVM_LT_INT: STI(mvm, -2) = (STI(mvm, -2) < STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LT_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) < STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LT_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) < 0); mvm->stack.stack_pointer--; pc++; break; case MVM_LE_INT: STI(mvm, -2) = (STI(mvm, -2) <= STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LE_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) <= STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LE_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) <= 0); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_INT: STI(mvm, -2) = (STI(mvm, -2) != STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) != STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_OBJECT: STI_WRITE(mvm, -2, STO(mvm, -2) != STO(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) != 0); mvm->stack.stack_pointer--; pc++; break; case MVM_LOGICAL_AND: STI(mvm, -2) = (STI(mvm, -2) && STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LOGICAL_OR: STI(mvm, -2) = (STI(mvm, -2) || STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LOGICAL_NOT: STI(mvm, -1) = !STI(mvm, -1); pc++; break; case MVM_POP: mvm->stack.stack_pointer--; pc++; break; case MVM_DUPLICATE: mvm->stack.stack[mvm->stack.stack_pointer] = mvm->stack.stack[mvm->stack.stack_pointer-1]; mvm->stack.stack_pointer++; pc++; break; case MVM_JUMP: pc = GET_2BYTE_INT(&code[pc+1]); break; case MVM_JUMP_IF_TRUE: if (STI(mvm, -1)) { pc = GET_2BYTE_INT(&code[pc+1]); } else { pc += 3; } mvm->stack.stack_pointer--; break; case MVM_JUMP_IF_FALSE: if (!STI(mvm, -1)) { pc = GET_2BYTE_INT(&code[pc+1]); } else { pc += 3; } mvm->stack.stack_pointer--; break; case MVM_PUSH_FUNCTION: STI_WRITE(mvm, 0, GET_2BYTE_INT(&code[pc+1])); mvm->stack.stack_pointer++; pc += 3; break; case MVM_INVOKE: { int func_idx = STI(mvm, -1); if (mvm->function[func_idx].kind == NATIVE_FUNCTION) { invoke_native_function(mvm, &mvm->function[func_idx], &mvm->stack.stack_pointer); pc++; } else { invoke_minic_function(mvm, &func, &mvm->function[func_idx], &code, &code_size, &pc, &mvm->stack.stack_pointer, &base, &exe); } break; } case MVM_RETURN: return_function(mvm, &func, &code, &code_size, &pc, &mvm->stack.stack_pointer, &base, &exe); break; case MVM_NEW_ARRAY: { int dim = code[pc+1]; MVM_TypeSpecifier *type = &exe->type_specifier[GET_2BYTE_INT(&code[pc+2])]; MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array(mvm, dim, type); mvm->stack.stack_pointer -= dim; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 4; break; } case MVM_NEW_ARRAY_LITERAL_INT: /* FALLTHRU */ { int size = GET_2BYTE_INT(&code[pc+1]); MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array_literal_int(mvm, size); mvm->stack.stack_pointer -= size; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 3; break; } case MVM_NEW_ARRAY_LITERAL_DOUBLE: /* FALLTHRU */ { int size = GET_2BYTE_INT(&code[pc+1]); MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array_literal_double(mvm, size); mvm->stack.stack_pointer -= size; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 3; break; } case MVM_NEW_ARRAY_LITERAL_OBJECT: /* FALLTHRU */ { int size = GET_2BYTE_INT(&code[pc+1]); MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array_literal_object(mvm, size); mvm->stack.stack_pointer -= size; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 3; break; } default: break; } /* MEM_check_all_blocks(); */ } //return ret; }
// psjailbreak, PL3, etc destroy this function to copy their code there. // We don't need that, but let's dummy the function just in case that patch is really necessary { mem_base2, LI(R3, 1) }, { mem_base2 + 4, BLR }, // sys_sm_shutdown, for ps2 let's pass to copy_from_user a fourth parameter { shutdown_patch_offset, MR(R6, R31) }, { module_sdk_version_patch_offset, NOP }, // User thread prio hack (needed for netiso) { user_thread_prio_patch, NOP }, { user_thread_prio_patch2, NOP }, // ODE Protection removal (needed for CFW 4.60+) { lic_patch, LI(R3, 1) }, { ode_patch, LI(R3, 0) }, { ode_patch+4, STD(R3, 0, R9) }, }; #define N_KERNEL_PATCHES (sizeof(kernel_patches) / sizeof(Patch)) f_desc_t extended_syscall8; int64_t syscall8(uint64_t function, uint64_t param1, uint64_t param2, uint64_t param3, uint64_t param4, uint64_t param5, uint64_t param6, uint64_t param7); LV2_SYSCALL2(uint64_t, sys_cfw_peek, (uint64_t *addr)) { /* if (block_peek) return (uint64_t)ENOSYS; */
ODRX_NO_CONS_DEFINE_MEMBERS(OdDbEntity_Dumper, OdRxObject) ExProtocolExtension::ExProtocolExtension() { } ExProtocolExtension::~ExProtocolExtension() { if(m_pDumpers) uninitialize(); } // dumps common data (for all entities) void dumpCommonData(OdDbEntity* pEnt, STD(ostream) & os) { OdDbHandle hTmp; char buff[20]; hTmp = pEnt->getDbHandle(); hTmp.getIntoAsciiBuffer(buff); os << " " << pEnt->isA()->name() << ", " << buff << STD(endl); } // this method is called for all entities for which there // aren't peculiar approach yet void OdDbEntity_Dumper::dump(OdDbEntity* pEnt, STD(ostream) & os) const { dumpCommonData(pEnt, os);
void OdGiWorldGeometryDumper::polygon(OdInt32 nbPoints, const OdGePoint3d* pVertexList) { m_os << " " << "polygon()" << STD(endl); }
void OdGiWorldGeometryDumper::circle(const OdGePoint3d& center, double radius, const OdGeVector3d& normal) { m_os << " " << "circle()" << STD(endl); }
void OdGiWorldGeometryDumper::pushModelTransform(const OdGeMatrix3d& xMat) { m_os << " " << "pushModelTransform()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setLayer(OdDbStub* layerId) { m_os << " " << "setLayer()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setTrueColor(const OdCmEntityColor& cmColor) { m_os << " " << "setTrueColor()" << STD(endl); }
//---------------------------------------------------------- // // OdGiSubEntityTraitsDumper // //---------------------------------------------------------- void OdGiSubEntityTraitsDumper::setColor(OdUInt16 color) { m_os << " " << "setColor()" << STD(endl); }
void OdGiWorldGeometryDumper::popClipBoundary() { m_os << " " << "popClipBoundary()" << STD(endl); }
void OdGiWorldGeometryDumper::pushClipBoundary(OdGiClipBoundary* pBoundary) { m_os << " " << "pushClipBoundary()" << STD(endl); }
void OdGiWorldGeometryDumper::nurbs(const OdGeNurbCurve3d& nurbs) { m_os << " " << "nurbs()" << STD(endl); }
//---------------------------------------------------------- // // OdGiWorldGeometryDumper // //---------------------------------------------------------- void OdGiWorldGeometryDumper::setExtents(const OdGePoint3d *pNewExtents) { m_os << " " << "setExtents()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setPlotStyleName(OdDb::PlotStyleNameType, OdDbStub*) { m_os << " " << "setPlotStyleName()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setMaterial(OdDbStub* materialId) { m_os << " " << "setMaterial()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setLineType(OdDbStub* linetypeId) { m_os << " " << "setLineType()" << STD(endl); }
void OdGiWorldGeometryDumper::popModelTransform() { m_os << " " << "popModelTransform()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setSelectionMarker(OdInt32 markerId) { m_os << " " << "setSelectionMarker()" << STD(endl); }
void OdGiWorldGeometryDumper::circle(const OdGePoint3d&, const OdGePoint3d&, const OdGePoint3d&) { m_os << " " << "circle()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setFillType(OdGiFillType fillType) { m_os << " " << "setFillType()" << STD(endl); }
void OdGiWorldGeometryDumper::pline(const OdGiPolyline& lwBuf, OdUInt32 fromIndex, OdUInt32 numSegs) { m_os << " " << "pline()" << STD(endl); }
void OdGiWorldGeometryDumper::pushModelTransform(const OdGeVector3d& vNormal) { m_os << " " << "pushModelTransform()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setLineWeight(OdDb::LineWeight lw) { m_os << " " << "setLineWeight()" << STD(endl); }
void OdGiSubEntityTraitsDumper::setLineTypeScale(double dScale) { m_os << " " << "setLineTypeScale()" << STD(endl); }
{ 0 } }; SprxPatch psp_emulator_patches[] = { // Sets psp mode as opossed to minis mode. Increases compatibility, removes text protection and makes most savedata work { psp_set_psp_mode_offset, LI(R4, 0), &condition_psp_iso }, { 0 } }; SprxPatch emulator_api_patches[] = { // Read umd patches { psp_read, STDU(SP, 0xFF90, SP), &condition_psp_iso }, { psp_read+4, MFLR(R0), &condition_psp_iso }, { psp_read+8, STD(R0, 0x80, SP), &condition_psp_iso }, { psp_read+0x0C, MR(R8, R7), &condition_psp_iso }, { psp_read+0x10, MR(R7, R6), &condition_psp_iso }, { psp_read+0x14, MR(R6, R5), &condition_psp_iso }, { psp_read+0x18, MR(R5, R4), &condition_psp_iso }, { psp_read+0x1C, MR(R4, R3), &condition_psp_iso }, { psp_read+0x20, LI(R3, SYSCALL8_OPCODE_READ_PSP_UMD), &condition_psp_iso }, { psp_read+0x24, LI(R11, 8), &condition_psp_iso }, { psp_read+0x28, SC, &condition_psp_iso }, { psp_read+0x2C, LD(R0, 0x80, SP), &condition_psp_iso }, { psp_read+0x30, MTLR(R0), &condition_psp_iso }, { psp_read+0x34, ADDI(SP, SP, 0x70), &condition_psp_iso }, { psp_read+0x38, BLR, &condition_psp_iso }, // Read header patches { psp_read+0x3C, STDU(SP, 0xFF90, SP), &condition_psp_iso }, { psp_read+0x40, MFLR(R0), &condition_psp_iso },
void OdGiSubEntityTraitsDumper::setThickness(double dThickness) { m_os << " " << "setThickness()" << STD(endl); }
/* standard for all. */ void (*add)(JamView *view); void (*remove)(JamView *view); gboolean (*visible)(JamView *view); void (*load)(JamView *view); void (*store)(JamView *view); /* only defined if it matters when the account changes. */ void (*account_changed)(JamView *view); } metas[] = { /* these must match JamViewMeta in jamview.h. */ #define STD(x) x##_add, x##_remove, x##_visible, x##_load, x##_store { "subject", TRUE, NULL, NULL, NULL, subject_load, subject_store, NULL }, { "security", TRUE, STD(security), security_account_changed }, { "mood", TRUE, STD(mood), mood_account_changed }, { "picture", TRUE, STD(picture), picture_account_changed }, { "music", TRUE, STD(music), NULL }, { "location", TRUE, STD(location), NULL }, { "tags", TRUE, STD(tags), NULL }, { "preformatted", TRUE, STD(preformatted), NULL }, { "datesel", TRUE, STD(datesel), NULL }, { "comments", TRUE, STD(comments), NULL }, { 0 } }; gboolean jam_view_get_meta_visible(JamView *view, JamViewMeta meta) { if (!metas[meta].visible) return TRUE; return metas[meta].visible(view);
void OdGiWorldGeometryDumper::text(const OdGePoint3d& position, const OdGeVector3d& normal, const OdGeVector3d& direction, double height, double width, double oblique, const OdChar* msg) { m_os << " " << "text()" << STD(endl); }