//---------------------------------------------------------- void ofTextureAdv::setPoints(ofPoint inputPts[4], ofPoint outputPts[4]){ for (int i = 0; i < 4; i++){ quad[i].set(outputPts[i].x, outputPts[i].y, 0); utQuad[i].set(inputPts[i].x, inputPts[i].y, 0); } updatePoints(); }
void LC_DlgSplinePoints::setSpline(LC_SplinePoints& b) { bezier = &b; //pen = spline->getPen(); ui->wPen->setPen(b.getPen(false), true, false, "Pen"); RS_Graphic* graphic = b.getGraphic(); if (graphic) { ui->cbLayer->init(*(graphic->getLayerList()), false, false); } RS_Layer* lay = b.getLayer(false); if (lay) { ui->cbLayer->setLayer(*lay); } ui->cbClosed->setChecked(b.isClosed()); //number of control points auto const& bData = b.getData(); auto const n = bData.splinePoints.size(); if (n <= 2) { ui->rbControlPoints->setChecked(true); ui->rbSplinePoints->setEnabled(false); } else ui->rbSplinePoints->setChecked(true); updatePoints(); }
//the game loop, calls all of the supplemental //methods of the application to continuously //update and maintain the functionality of the //game void Application::gameLoop() { while(gameRunning) { handleEnvironment(); updateMonsters(); handleEvents(); updatePlayer(); handleArrows(); handlePhysics(); delta.start(); checkBoundaries(); updateFPS(); updatePoints(); drawSurface(); if(finished) { showFinal(); } } }
void GeneticAlgorithm::run() { initGenerator(); for (int i = 0; i < GA_MAXITER; i++) { QList<double> *points = new QList<double>(); for( int j = 0; j < GA_POWER; j++){ points->append(m_genotype.at(j).x); } emit updatePoints(points); reproductionOperator(); mutationOperator(); reductionOperator(); QVector<gene> tmp = m_genotype; tmp.removeAll(tmp.first()); if (tmp.isEmpty()) { qDebug() << "EARLY END"; qDebug() << "Total iterations: " << i; break; } } qDebug() << "Result:" << m_genotype.last().fitness; }
void BoxContact::update() { /** * Retrieve boxes */ auto & shapeA = (BoxShape&)*m_bodyA.shape(); auto & shapeB = (BoxShape&)*m_bodyB.shape(); auto boxA = shapeA.instanciate(m_bodyA.transform()); auto boxB = shapeB.instanciate(m_bodyB.transform()); /** * Intersect */ CollideBox3D collideBox3D(boxA, boxB); m_intersect = collideBox3D.execute(); /** * Update contact points */ if (m_intersect) { updatePoints({collideBox3D.numIntersections, collideBox3D.intersections}); } else { clearPoints(); } }
EditCurve::EditCurve(BezierCurve *targetCurve, Color curveColor) : UIElement() { this->targetCurve = targetCurve; poly = new Polycode::Polygon(); for(int i=0; i < CURVE_SIZE; i++) { poly->addVertex(0.0, 0.0, 0.0); } visMesh = new ScreenMesh(Mesh::LINE_STRIP_MESH); visMesh->getMesh()->addPolygon(poly); visMesh->lineSmooth = true; visMesh->lineWidth = 2.0; addChild(visMesh); visMesh->setPosition(0, 254); visMesh->color = curveColor; pointsBase = new UIElement(); addChild(pointsBase); pointToRemove = NULL; updateCurve(); updatePoints(); Deactivate(); }
ArbRamp::ArbRamp(QWidget *parent) : QMainWindow(parent), ui(new Ui::ArbRamp) { ui->setupUi(this); curLine=-1; nLines=0; render=new RenderRamp(); ui->scrollArea->setWidget(render); delegate=new RampDelegate(ui->tableWidget); ui->tableWidget->setItemDelegate(delegate); setCurrentFile(""); curDir=""; readSettings(); addAction=new QAction(tr("Insert"),this); delAction=new QAction(tr("Delete"),this); updateAction=new QAction(tr("Update view"),this); ui->mainToolBar->addAction(addAction); ui->mainToolBar->addAction(delAction); ui->mainToolBar->addAction(updateAction); //Connect signal and slots. connect(ui->action_About,SIGNAL(triggered()),this,SLOT(about())); connect(ui->action_Quit,SIGNAL(triggered()),this,SLOT(close())); connect(ui->action_Save,SIGNAL(triggered()),this,SLOT(save())); connect(ui->actionSave_As,SIGNAL(triggered()),this,SLOT(saveAs())); connect(ui->action_Open,SIGNAL(triggered()),this,SLOT(open())); connect(ui->actionNew,SIGNAL(triggered()),this,SLOT(newRamp())); connect(ui->action_Export,SIGNAL(triggered()),this,SLOT(exportRamp())); connect(ui->mainToolBar,SIGNAL(actionTriggered(QAction*)),this, SLOT(chooseAction(QAction*))); connect(this,SIGNAL(renderUpdate(QList<QPoint>)),render, SLOT(updatePoints(QList<QPoint>))); connect(ui->tableWidget,SIGNAL(currentCellChanged(int,int,int,int)),this, SLOT(currentLine(int,int,int,int))); //So that wasModified has access to the real size of the RenderRamp object. show(); wasModified(); }
void CircleShape::setPointCount( size_t count ) { m_pointCount = count; m_vertices.resize( m_pointCount ); updatePoints(); }
//-------------------------------------------------------------- void Wave::update(float dt) { m_age += dt; if (m_age>m_ageMax) m_age = m_ageMax; m_color.a = 255*(1.0-m_age/m_ageMax); m_radius += m_radiusSpeed*dt; updatePoints(); }
void DrawingItemGroup::removeItem(DrawingItem* item) { if (item && containsItem(item)) { mItems.removeAll(item); updatePoints(); } }
void DrawingItemGroup::addItem(DrawingItem* item) { if (item && !containsItem(item)) { mItems.append(item); updatePoints(); } }
void DrawingItemGroup::flipItem(const QPointF& parentPos) { DrawingItem::flipItem(parentPos); for(auto itemIter = mItems.begin(); itemIter != mItems.end(); itemIter++) (*itemIter)->flipItem(QPointF(0.0, 0.0)); updatePoints(); }
void EditCurve::Update() { if(pointToRemove) { targetCurve->removePoint(pointToRemove->point); updatePoints(); updateCurve(); pointToRemove = NULL; } }
void PathStrokeRenderer::timerEvent(QTimerEvent *e) { if (e->timerId() == m_timer.timerId()) { updatePoints(); } // else if (e->timerId() == m_fpsTimer.timerId()) { // emit frameRate(m_frameCount); // m_frameCount = 0; // } }
//---------------------------------------------------------- void ofTextureAdv::setPoint(int which, float x, float y){ if( which>4 || which < 0){ printf("ofTextureAdv:: please choose point 0-3\n"); return; } quad[which].set(x, y, 0); updatePoints(); }
//-------------------------------------------------------------- void Wave::setNbPoints(int nb) { if (nb != m_nbPoints) { m_nbPoints = nb; m_points.clear(); for (int i=0;i<m_nbPoints;i++) { m_points.push_back( ofVec3f() ); } } updatePoints(); }
void WarpedWorld::updatePointPos() { int dragX = mX - prevPoint.x; int dragY = mY - prevPoint.y; if(fastMove == true) { dragX *= 1.8; dragY *= 1.8; } // check if corner is selected. if(corner >= 0) { quad.setOutputPoint(corner, ofPoint(currentPt.x+dragX, currentPt.y+dragY)); updatePoints(); } }
/** * @brief Updates characters health if it takes damage and health is refreshed etc. * @param health The amount of health to add/subtract. * @todo when dead give signal to pop-up menu or something like that. * @return true if alive, false if dead */ bool Character::updateCharacterHealth(int health) { characterHealth += health; if (DEBUG > 0) { printf("\nCharacter::updateCharacterHealth(int): player %d's health is %d \n",characterID, characterHealth); } if(characterHealth < 1) { updatePoints(-1); if (DEBUG > 0) { printf("\n\n---player %d is dead %d points---\n\n",characterID, pointsValue); } updateCharacterHealth(10); ///< resets characters health if dead return false; } return true; }
ArchimedeanSpiral::ArchimedeanSpiral(double x0, double y0, double a) { init(); m_name = QCoreApplication::translate("ArchimedeanSpiral", "Archimedean Spiral"); m_param = Parameter(0, 3.99, "t"); m_param.interval().setLowerEnd(0, true); Variable var("a", a); var.interval().setLowerEnd(0); var.setColor(QColor(255, 128, 0)); setVariable(var); setVariable("x0", x0, false); setVariable("y0", y0, false); initDimension(); updatePoints(); }
Lemniscate::Lemniscate(double a, double x0, double y0) { init(); m_name = QCoreApplication::translate("Lemniscate", "Lemniscate"); m_param = Parameter(0, 2*PI, "t"); m_param.interval().setLowerEnd(0, true); m_param.interval().setUpperEnd(2 * PI, true); Variable var("a", a); var.interval().setLowerEnd(0); var.setColor(QColor(255, 128, 0)); setVariable(var); setVariable("x0", x0, false); setVariable("y0", y0, false); initDimension(); updatePoints(); }
void CTFObjectiveResource :: think () { if ( m_bInitialised && ( m_fNextCheckMonitoredPoint < engine->Time() ) ) { bool bupdate = (m_fUpdatePointTime < engine->Time()); int team = 0; do { if ( m_iMonitorPoint[team] != -1 ) { for ( int j = 0; j < MAX_PREVIOUS_POINTS; j ++ ) { int prev = GetPreviousPointForPoint(m_iMonitorPoint[team],(team+2),j); if ( (prev != -1) && (GetOwningTeam(prev)!=(team+2)) ) { bupdate = true; break; } } } team++; }while ((team < 2) && (bupdate==false)); if ( bupdate ) { extern ConVar rcbot_tf2_autoupdate_point_time; updatePoints(); m_fNextCheckMonitoredPoint = engine->Time() + 5.0f; m_fUpdatePointTime = engine->Time() + rcbot_tf2_autoupdate_point_time.GetFloat(); } else m_fNextCheckMonitoredPoint = engine->Time() + 1.0f; } }
Cycloid::Cycloid(double r, double m, double x0, double y0) { init(); m_name = QCoreApplication::translate("Cycloid", "Cycloid"); m_param = Parameter(-2*PI, 2*PI, "t"); Variable var("r",r); var.interval().setLowerEnd(0); var.setColor(QColor(255, 128, 0)); setVariable(var); var = Variable("mu", m); var.setColor(QColor(0, 128, 255)); var.setFormula("<mi color=\"#0088FF\">μ</mi>"); setVariable(var); setVariable("x0", x0, false); setVariable("y0", y0, false); updatePoints(); initDimension(); }
void DrawingItemGroup::clearItems() { while (!mItems.empty()) delete mItems.takeLast(); updatePoints(); }
void SegmentShape::setPoints(const Vector2f& p1, const Vector2f& p2) { updatePoints(p1, p2); setPosition(m_center.toSFML()); }
void Background::update() { move(); updatePoints(); }
bool Plot3DDialog::updatePlot() { int axis=-1; if (generalDialog->currentWidget()==(QWidget*)bars) { emit updateBars(boxBarsRad->text().toDouble()); } if (generalDialog->currentWidget()==(QWidget*)points) { if (boxPointStyle->currentItem() == 0) emit updatePoints(boxSize->text().toDouble(), boxSmooth->isChecked()); else if (boxPointStyle->currentItem() == 1) emit updateCross(boxCrossRad->text().toDouble(), boxCrossLinewidth->text().toDouble(), boxCrossSmooth->isChecked(), boxBoxed->isChecked()); else if (boxPointStyle->currentItem() == 2) emit updateCones(boxConesRad->text().toDouble(), boxQuality->value()); } if (generalDialog->currentWidget()==(QWidget*)title) { emit updateTitle(boxTitle->text(),titleColor,titleFont); } if (generalDialog->currentWidget()==(QWidget*)colors) { emit updateTransparency(boxTransparency->value()*0.01); emit updateDataColors(fromColor,toColor); emit updateColors(meshColor,axesColor,numColor,labelColor,bgColor,gridColor); } if (generalDialog->currentWidget()==(QWidget*)general) { emit showColorLegend(boxLegend->isChecked()); emit updateMeshLineWidth(boxMeshLineWidth->value()); emit adjustLabels(boxDistance->value()); emit updateResolution (boxResolution->value()); emit showColorLegend(boxLegend->isChecked()); emit setNumbersFont(numbersFont); emit updateZoom(boxZoom->value()*0.01); emit updateScaling(boxXScale->value()*0.01,boxYScale->value()*0.01, boxZScale->value()*0.01); } if (generalDialog->currentWidget()==(QWidget*)scale) { axis=axesList->currentRow(); QString from=boxFrom->text().toLower(); QString to=boxTo->text().toLower(); double start,end; bool error=false; try { MyParser parser; parser.SetExpr(from.toAscii().constData()); start=parser.Eval(); } catch(mu::ParserError &e) { QMessageBox::critical(0,tr("Start limit error"), QString::fromStdString(e.GetMsg())); boxFrom->setFocus(); error=true; return false; } try { MyParser parser; parser.SetExpr(to.toAscii().constData()); end=parser.Eval(); } catch(mu::ParserError &e) { QMessageBox::critical(0,tr("End limit error"), QString::fromStdString(e.GetMsg())); boxTo->setFocus(); error=true; return false; } if (start>=end) { QMessageBox::critical(0,tr("Input error"), tr("Please enter scale limits that satisfy: from < to!")); boxTo->setFocus(); return false; } if (! error) emit updateScale(axis,scaleOptions(axis, start, end, boxMajors->text(), boxMinors->text())); } if (generalDialog->currentWidget()==(QWidget*)axes) { axis=axesList2->currentRow(); labels[axis] = boxLabel->text(); emit updateLabel(axis, boxLabel->text(),axisFont(axis)); emit updateTickLength(axis,boxMajorLength->text().toDouble(), boxMinorLength->text().toDouble()); } return true; }
int POINT_EDITOR::OnSelectionChange( const TOOL_EVENT& aEvent ) { const SELECTION& selection = m_selectionTool->GetSelection(); if( selection.Size() == 1 ) { Activate(); KIGFX::VIEW_CONTROLS* controls = getViewControls(); KIGFX::VIEW* view = getView(); PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>(); EDA_ITEM* item = selection.items.GetPickedItem( 0 ); m_editPoints = EDIT_POINTS_FACTORY::Make( item, getView()->GetGAL() ); if( !m_editPoints ) return 0; view->Add( m_editPoints.get() ); m_editedPoint = NULL; bool modified = false; // Main loop: keep receiving events while( OPT_TOOL_EVENT evt = Wait() ) { if( !m_editPoints || evt->Matches( m_selectionTool->ClearedEvent ) || evt->Matches( m_selectionTool->UnselectedEvent ) || evt->Matches( m_selectionTool->SelectedEvent ) ) { break; } if( evt->IsMotion() ) { EDIT_POINT* point = m_editPoints->FindPoint( evt->Position() ); if( m_editedPoint != point ) setEditedPoint( point ); } else if( evt->IsAction( &COMMON_ACTIONS::pointEditorAddCorner ) ) { addCorner( controls->GetCursorPosition() ); updatePoints(); } else if( evt->IsAction( &COMMON_ACTIONS::pointEditorRemoveCorner ) ) { if( m_editedPoint ) { removeCorner( m_editedPoint ); updatePoints(); } } else if( evt->IsDrag( BUT_LEFT ) && m_editedPoint ) { if( !modified ) { // Save items, so changes can be undone editFrame->OnModify(); editFrame->SaveCopyInUndoList( selection.items, UR_CHANGED ); controls->ForceCursorPosition( false ); m_original = *m_editedPoint; // Save the original position controls->SetAutoPan( true ); modified = true; } bool enableAltConstraint = !!evt->Modifier( MD_CTRL ); if( enableAltConstraint != (bool) m_altConstraint ) // alternative constraint setAltConstraint( enableAltConstraint ); m_editedPoint->SetPosition( controls->GetCursorPosition() ); if( m_altConstraint ) m_altConstraint->Apply(); else m_editedPoint->ApplyConstraint(); updateItem(); updatePoints(); m_editPoints->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY ); } else if( evt->IsAction( &COMMON_ACTIONS::pointEditorUpdate ) ) { updatePoints(); } else if( evt->IsMouseUp( BUT_LEFT ) ) { controls->SetAutoPan( false ); setAltConstraint( false ); modified = false; m_toolMgr->PassEvent(); } else if( evt->IsCancel() ) { if( modified ) // Restore the last change { wxCommandEvent dummy; editFrame->RestoreCopyFromUndoList( dummy ); updatePoints(); modified = false; } // Let the selection tool receive the event too m_toolMgr->PassEvent(); break; } else { m_toolMgr->PassEvent(); } } if( m_editPoints ) { finishItem(); item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY ); view->Remove( m_editPoints.get() ); m_editPoints.reset(); } controls->ShowCursor( false ); controls->SetAutoPan( false ); controls->SetSnapping( false ); controls->ForceCursorPosition( false ); } return 0; }
int main (int argc, char **argv) { Options mergetr = readParameters (argc, argv); char filename_mesh_node[FILENAME_MAX]; char filename_mesh_ele[FILENAME_MAX]; char filename_otoczka[FILENAME_MAX]; char filename_output_node[FILENAME_MAX]; char filename_output_ele[FILENAME_MAX]; int no_of_meshes = argc-mergetr.args_start; strcpy (filename_otoczka, mergetr.input); if ( strstr (filename_otoczka, ".poly") == NULL) strcat (filename_otoczka, ".poly"); strcpy (filename_output_node, mergetr.output); strcat (filename_output_node, ".node"); strcpy (filename_output_ele, mergetr.output); strcat (filename_output_ele, ".ele"); fprintf(stdout, "************************************\n"); fprintf(stdout, "***** M * E * R * G * E * T * R ****\n"); fprintf(stdout, "************************************\n"); fprintf(stdout, "* Otoczka filename: %s\n", filename_otoczka); fprintf(stdout, "* Output filenames: %s & %s\n", filename_output_node, filename_output_ele); fprintf(stdout, "* Triangle options: %s\n", mergetr.tr_opt); fprintf(stdout, "************************************\n"); struct triangulateio *siatka; struct triangulateio otoczka; struct triangulateio out; EdgeList **v; PointList **p; int i; siatka = malloc ( no_of_meshes * sizeof *siatka); v = malloc ( no_of_meshes * sizeof **v ); p = malloc ( no_of_meshes * sizeof **p ); if (siatka == NULL || v == NULL || p == NULL) { fprintf (stderr, "** Error! Not enough memory!"); return -1; } initTriangulation (&otoczka); /* OTOCZKA */ FILE *file_otoczka = fopen( filename_otoczka, "r"); if (file_otoczka == NULL) { fprintf(stderr, "** Error while opening %s\n", filename_otoczka); return -100; } readPoints (file_otoczka, &otoczka); readSegments (file_otoczka, &otoczka); readHoles (file_otoczka, &otoczka); readRegions (file_otoczka, &otoczka); fclose (file_otoczka); /* MESHES */ for (i = 0; i < (argc - mergetr.args_start); i++) { strcpy (filename_mesh_node, argv[mergetr.args_start+i]); strcat (filename_mesh_node, ".node"); strcpy (filename_mesh_ele, argv[mergetr.args_start+i]); strcat (filename_mesh_ele, ".ele"); fprintf(stdout, "************************************\n"); fprintf(stdout, "* Mesh filenames: %s & %s\n", filename_mesh_node, filename_mesh_ele); fprintf(stdout, "************************************\n"); FILE *file_mesh_node = fopen( filename_mesh_node, "r"); FILE *file_mesh_ele = fopen( filename_mesh_ele, "r"); if (file_mesh_node == NULL) { fprintf(stderr, "** Error while opening %s\n", filename_mesh_node); return -101; } if (file_mesh_node == NULL) { fprintf(stderr, "** Error while opening %s\n", filename_mesh_ele); return -102; } initTriangulation (&siatka[i]); readPoints (file_mesh_node, &siatka[i]); readTriangles (file_mesh_ele, &siatka[i]); fclose (file_mesh_node); fclose (file_mesh_ele); v[i] = createEdgeList(siatka[i]); markBndEdges (siatka[i], v[i]); p[i] = makePointList (otoczka, siatka[i], v[i]); updatePoints (&otoczka, siatka[i], v[i], p[i]); updateSegments (&otoczka, siatka[i], v[i], p[i]); updateHoles (&otoczka, siatka[i]); } fprintf(stdout, "************************************\n"); /* TRIANGULAtE */ initTriangulation (&out); strcat (mergetr.tr_opt, "pYYQ"); triangulate (mergetr.tr_opt, &otoczka, &out, (struct triangulateio *) NULL); /* GLUE HOLES */ /* markNotBndEdges (siatka1, v); */ for (i = 0; i < no_of_meshes; i++) { glueNotBndPoints (&out, siatka[i], p[i]); /* DOKLEJANIE DO OUT */ fixPointListNumbers (&out, &siatka[i], p[i]); glueInteriorTriangles (&out, siatka[i], p[i]); removeHole (&out); } FILE *file_output_node = fopen (filename_output_node, "w"); FILE *file_output_ele = fopen (filename_output_ele, "w"); writePoints (file_output_node, out); writeTriangles (file_output_ele, out); fclose (file_output_node); fclose (file_output_ele); fprintf(stdout, "************************************\n"); free (p); free (v); freeTriangulation (&otoczka); freeTriangulation (&out); for (i = 0; i < no_of_meshes; i++) freeTriangulation (&siatka[i]); return 0; }
void SimpleChart::init() { // Set the time to zero time = sf::Time(sf::Time::Zero); // initialize the axis xAxis.setOrigin(xAxis.getLocalBounds().width / 2, xAxis.getLocalBounds().height / 2); yAxis.setOrigin(yAxis.getLocalBounds().width / 2, yAxis.getLocalBounds().height / 2); xAxis.setPosition(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2); yAxis.setPosition(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2); yAxis.rotate(90); xAxis.setFillColor(AXIS_COLOR); yAxis.setFillColor(AXIS_COLOR); // Load the fonts quicksandFontBold.loadFromFile(QUICKSAND_BOLD_FONT); quicksandFontRegular.loadFromFile(QUICKSAND_REGULAR_FONT); // Initialize the title title.setString(SIMPLE_TITLE_STRING); title.setFont(quicksandFontBold); title.setPosition(SIMPLE_TITLE_POS_X, SIMPLE_TITLE_POS_Y); title.setCharacterSize((uint)SIMPLE_TITLE_SIZE); // initialize the function name functionName.setString(getFunctionTitle()); functionName.setFont(quicksandFontRegular); functionName.setPosition(SIMPLE_FUNCTION_POS_X, SIMPLE_FUNCTION_POS_Y); functionName.setCharacterSize((uint)SIMPLE_FUNCTION_SIZE); // initialize the variable names for (int i = 0; i < variables.index.size(); i++) { sf::Text newVariableName; variableNames.push_back(newVariableName); variableNames[i].setFont(quicksandFontBold); variableNames[i].setPosition(SIMPLE_OPTION_POS_X[i], SIMPLE_OPTION_POS_Y); variableNames[i].setCharacterSize((uint)SIMPLE_OPTION_SIZE); // Set the string of the variable names variableNames[i].setString(SIMPLE_OPTION[variables.index[i]]); } // initialize the values of the variables for (int i = 0; i < variables.index.size(); i++) { sf::Text newVariableValue; variableValue.push_back(newVariableValue); variableValue[i].setFont(quicksandFontRegular); variableValue[i].setPosition(SIMPLE_OPTION_POS_X[i], SIMPLE_OPTION_VALUE_POS_Y); variableValue[i].setCharacterSize((uint)SIMPLE_OPTION_SIZE); } // nitialize the annotations for (int i = 0; i < 3; i++) { sf::Text newAnnotation; annotation.push_back(newAnnotation); annotation[i].setFont(quicksandFontRegular); annotation[i].setString(ANNOTATION[i]); annotation[i].setPosition(ANNOTATION_POS_X, ANNOTATION_POS_Y[i]); annotation[i].setCharacterSize((uint)ANNOTATION_SIZE); } // Start the axis with the default scale updateScale(); // Start the points with the default variables and scale updatePoints(); // initialize the selected option selected = 0; }
void SimpleChart::update() { time += clock.restart(); if (time > sf::seconds(KEYBOARD_DELAY)) { // If user presses escape the window goes back to the function selector if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Escape)) { this->changeState(this->stateManager, new SelectFunction()); } // If the user presses "+", the chart zooms in if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Add) && !addKey) { zoomIn(); updatePoints(); variables.setScale((int)scale); } // If the user presses "+", the chart zooms out if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Subtract) && !subtractKey) { zoomOut(); updatePoints(); variables.setScale((int)scale); } } // If the user presses R, the selected variable randomize if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::R) && !rKey) { variables.randomize(selected); updatePoints(); } // If the user presses up, the selected variable increase if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Up)) { variables.increase(selected); updatePoints(); } // If the user presses down, the selected variable decrease if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Down)) { variables.decrease(selected); updatePoints(); } // If the user presses left, the variable at the left is selected if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Left) && !leftKey) selected--; // If the user presses right, the selected variable at the right is selected if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Right) && !rightKey) selected++; // Check if the selected variable reached the end of a side if (selected < 0) selected = (int)(variables.index.size() - 1); else if (selected >= (int)(variables.index.size())) selected = 0; // Check if a key is holded addKey = sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Add); subtractKey = sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Subtract); rKey = sf::Keyboard::isKeyPressed(sf::Keyboard::Key::R); leftKey = sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Left); rightKey = sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Right); }