void GPU::merge(uint32_t *input, size *positions, size n) const { cl::make_kernel<cl::Buffer&,cl::Buffer&,cl::Buffer&> merge(this->kmerge); cl::make_kernel<cl::Buffer&,size,size> updatePositions(this->kupdatePositions); cl::CommandQueue queue(context,dev); size len=positions[n]; cl::Buffer inputBuffer(context, CL_MEM_READ_WRITE, sizeof(uint32_t)*len); queue.enqueueWriteBuffer(inputBuffer, false, 0, sizeof(uint32_t)*len, input); cl::Buffer outputBuffer(context, CL_MEM_READ_WRITE, sizeof(uint32_t)*len); cl::Buffer positionsBuffer(context, CL_MEM_READ_WRITE, sizeof(size)*(n+1)); queue.enqueueWriteBuffer(positionsBuffer, false, 0, (n+1)*sizeof(size), positions); if(n%2) queue.enqueueCopyBuffer(inputBuffer, outputBuffer, sizeof(uint32_t)*positions[n-1],sizeof(uint32_t)*positions[n-1], (positions[n]-positions[n-1])*sizeof(uint32_t)); //kopiowanie ostatniego fragmentu, który przez pewien czas może nie być mergowany (jak długo jest nieparzysta liczba list) while(n>1) { // std::clog<<n<<": "; // std::copy(positions,positions+n+1,std::ostream_iterator<size>(std::clog," ")); // std::clog<<std::endl; merge(cl::EnqueueArgs(queue,n/2),inputBuffer,outputBuffer,positionsBuffer); size o=n; n-=n/2; updatePositions(cl::EnqueueArgs(queue,1),positionsBuffer,o,n); std::swap(inputBuffer,outputBuffer); } queue.enqueueReadBuffer(inputBuffer, false, 0, sizeof(uint32_t)*len, input); queue.finish(); }
void System<DataType,Integrator,Potential,Communicator>::simulate(int numIters, std::ostream & output) { // MPI Comms. // clearBuffers() ; appendTransitionsToBuffers() ; appendInteractionsToBuffers() ; communicateInteractionsTransitions() ; // Initialise the forces. // updateForces() ; // Prime the velocity based on the integration policy. // for (unsigned int i = 0 ; i < positions.size() ; i+=2) { Integrator::initialise(&positions[i], &velocities[i], &forces[i]) ; } // Update velocities and positions based on the integration policy. // for (int i = 0; i < numIters ; ++i) { updateVelocities() ; updatePositions() ; // MPI Comms. clearBuffers() ; appendTransitionsToBuffers() ; appendInteractionsToBuffers() ; communicateInteractionsTransitions() ; updateForces() ; printSystem(output,i) ; output << std::endl << std::endl ; } } /* ----- end of member function simulate ----- */
void DrawStack3D::draw() { updatePositions(); //al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA); stack.draw(); //al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); }
ProjectileOccurrence::ProjectileOccurrence( Projectile* projectile, const string& textureName, const Vector2f& position, const Vector2f& speed, State state, Side side, map<ProjectileOccurrence::State, int>& nbSpritesByState, map<ProjectileOccurrence::State, int>& frameDelayByState) : EntityMovable(textureName, position, speed, side), _sender(GENTILE), _state(state), _lifeTime(PausableClock()), _appearanceTime(PausableClock()), _animation(NB_STATES) { _projectile = projectile; /* Initialize animation class */ _animation.setMapNbSprites(nbSpritesByState); _animation.setMapFrameDelay(frameDelayByState); _animation.setCurrentState(state); /* Hitbox */ _deltaX = _projectile->getBottomLeft(); _hitboxSize.y = _projectile->getTop(); _hitboxSize.x = _texture->getSize().x / _animation.getNbSpritesMax() - 2 * _deltaX; updatePositions(position.x, position.y + _texture->getSize().y / nbSpritesByState.size() - _hitboxSize.y); }
void ProjectileOccurrence::updatePhysicData(float time, RenderWindow& app) { setActivity(app); if(_isActive) { if(_lifeTime.GetElapsedTime() > 0) { /* Submissions */ if(_projectile->getSubmission() & PhysicConstants::GRAVITY_SUBMISSION) gravity(_speed, time); /* Update physic position */ /* Save actual position in previous position */ _previousPosition = _position; /* Compute new position */ updatePositions(_hitboxPosition.x + time * _speed.x, _hitboxPosition.y + time * _speed.y); /* If it falls in hole */ /*if(_hitboxPosition.y + _hitboxSize.y < 0) _projectile->removeProjectileOccurrence(this);*/ if(_hitboxPosition.y < 0) _hitboxPosition.y = 0; } else { //_projectile->removeProjectileOccurrence(this); } } }
bool GamePromptCenter::initialize() { m_pNotice1 = gCtrlAllocator->LoadCtrl("Notice1"); m_pNotice2 = Layout::create(); m_pPrompt = Layout::create(); m_pNormal = Layout::create(); m_pIconsFrame = Layout::create(); if ( !m_pNotice1 || !m_pNotice2 || !m_pPrompt || !m_pNormal || !m_pIconsFrame ) { return false; } m_pNotice1->retain(); m_pNotice2->retain(); m_pPrompt->retain(); m_pNormal->retain(); m_pIconsFrame->retain(); m_pIconsFrame->setEnabled(false); m_pNotice1->setTouchEnabled(false); m_pIconsFrame->setTouchEnabled(false); initSystemIcons(); updatePositions(); m_pNotice1Frame = dynamic_cast<Layout*>(m_pNotice1->getChildByName("Panel_Clip")); if ( m_pNotice1Frame ) { m_pNotice1Frame->setClippingEnabled(true); } return true; }
LedManager::LedManager() { numHubs = 0; dragging = false; //string comPorts[3] = {"COM17","COM18","COM13"}; //must initialized with same length as numHubs ofColor colors[3] = {ofColor::orangeRed,ofColor::aliceBlue,ofColor::forestGreen}; //for(int i=0;i<1;i++) addHub(comPorts[i],460800,colors[i]); fbo.allocate(256,256); ledShader.load("LedShader/shader"); ledMapImage.allocate(256,256,ofImageType::OF_IMAGE_COLOR); ledMapPixels.allocate(256,256,ofImageType::OF_IMAGE_COLOR); ledPixels.allocate(256,256,ofImageType::OF_IMAGE_COLOR_ALPHA); int imgSize = ledMapImage.width*ledMapImage.height; updateLedMap(); setSendRate(50); updatePositions(); ofAddListener(timer.TIMER_REACHED,this,&LedManager::onUpdateTimer); }
void HUD::setHmsVisible(bool visible) { mHealth->setVisible(visible); mMagicka->setVisible(visible); mStamina->setVisible(visible); updatePositions(); }
int main(int argc, char *argv[]) { param params; AABB water_volume; AABB boundary_volume; fluid_particle *fluid_particles = NULL; boundary_particle *boundary_particles = NULL; initParams(&water_volume, &boundary_volume, ¶ms); initParticles(&fluid_particles, &boundary_particles, &water_volume, &boundary_volume, ¶ms); eulerStart(fluid_particles, boundary_particles, ¶ms); // Main simulation loop // Hint: Copy fluid_particles(params.number_fluid_particles), boundary_particles(params.number_boundary_particles), and params(1) for(int n=0; n<params.number_steps; n++) { updatePressures(fluid_particles, ¶ms); updateAccelerations(fluid_particles, boundary_particles, ¶ms); updatePositions(fluid_particles, ¶ms); if (n % params.steps_per_frame == 0) { // Hint: Make sure to update the host fluid_particle data writeFile(fluid_particles, ¶ms); } } // Hint: delete any acc data allocated finalizeParticles(fluid_particles, boundary_particles); return 0; }
int main(int argc, char *argv[]) { param params; AABB water_volume; AABB boundary_volume; fluid_particle *fluid_particles = NULL; boundary_particle *boundary_particles = NULL; initParams(&water_volume, &boundary_volume, ¶ms); initParticles(&fluid_particles, &boundary_particles, &water_volume, &boundary_volume, ¶ms); eulerStart(fluid_particles, boundary_particles, ¶ms); // Main simulation loop #pragma acc enter data copyin(fluid_particles[0:params.number_fluid_particles], boundary_particles[0:params.number_boundary_particles],params[0:1]) for(int n=0; n<params.number_steps; n++) { updatePressures(fluid_particles, ¶ms); updateAccelerations(fluid_particles, boundary_particles, ¶ms); updatePositions(fluid_particles, ¶ms); if (n % params.steps_per_frame == 0) { #pragma acc update host(fluid_particles[0:params.number_fluid_particles]) writeFile(fluid_particles, ¶ms); } } #pragma acc exit data delete(fluid_particles[0:params.number_fluid_particles],boundary_particles[0:params.number_boundary_particles],params[0:1]) finalizeParticles(fluid_particles, boundary_particles); return 0; }
void AudioBody::setOrientation (const Quaternion& v) { if (destroyed) THROW_DEAD(className); if (ambient) return; orientation = v; updatePositions(); }
void Sprite::setTextureRect(const Rect &rect) { if (rect != mTextureRect) { mTextureRect = rect; updatePositions(); updateTexCoords(); } }
void AudioBody::setSeparation (float v) { if (destroyed) THROW_DEAD(className); if (ambient) return; separation = v; updatePositions(); }
int main(int argc, char *argv[]) { param params; AABB water_volume; AABB boundary_volume; fluid_particle *fluid_particles = NULL; boundary_particle *boundary_particles = NULL; initParams(&water_volume, &boundary_volume, ¶ms); initParticles(&fluid_particles, &boundary_particles, &water_volume, &boundary_volume, ¶ms); eulerStart(fluid_particles, boundary_particles, ¶ms); // Main simulation loop for(int n=0; n<params.number_steps; n++) { updatePressures(fluid_particles, ¶ms); updateAccelerations(fluid_particles, boundary_particles, ¶ms); updatePositions(fluid_particles, ¶ms); if (n % params.steps_per_frame == 0) { writeFile(fluid_particles, ¶ms); } } finalizeParticles(fluid_particles, boundary_particles); return 0; }
GraphicNetCloud::GraphicNetCloud(raw_address address, QList<GraphicNetNode*> nodes, QGraphicsItem* parent) : QGraphicsObject(parent) { this->address = address; this->nodes = nodes; addressText = new QGraphicsSimpleTextItem(address.toString().c_str(), this); QFont textFont; textFont.setPixelSize(20); addressText->setFont(textFont); QBrush brush(Qt::black); addressText->setBrush(brush); QPixmap pic(":/media/cloudIcon"); icon = new QGraphicsPixmapItem(pic, this); //icon->scale(0.75, 0.75); //QRectF bounds = boundingRect(); for(int i=0; i<nodes.size(); i++){ nodes[i]->setParentItem(this); } updatePositions(); }
/**************************************************************************//** * @author Jaysen Spurlock, Joe Manke * * @brief This is the heart of the Pong application. It controls the frame rate * of the game, ensuring the updates seem appropriate to the user. This function * is in charge of updating objects' positions on screen, detecting collisions, * and checking for end-game status. * * @param value Unused variable required by GLUT *****************************************************************************/ void timer( int value ) { // Check for a winner if( LEFT_SCORE >= 10 || RIGHT_SCORE >= 10 ) { glutLeaveMainLoop(); return; } accelerateFromGravity(); // Check for collision with top or bottom wall if( ( BALL.velocity.y > 0 && BALL.center.y > 1.0f - PBall::BALL_RADIUS ) || ( BALL.velocity.y < 0 && BALL.center.y < PBall::BALL_RADIUS ) ) { BALL.velocity.y = -BALL.velocity.y; } // Only consider one side of the screen at a time if( BALL.center.x > 1.0f ) { rightSideCollisionCheck(); } else { leftSideCollisionCheck(); } updatePositions(); glutPostRedisplay(); glutTimerFunc( 30, timer, 0 ); }
void PerlinFace::update() { if (!_initialized) { init(); } updatePositions(); updateVertices(); glBindBuffer(GL_ARRAY_BUFFER, _vboID); glBufferData(GL_ARRAY_BUFFER, FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * _trianglesCount * sizeof(GLfloat), _triangles, GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, _nboID); glBufferData(GL_ARRAY_BUFFER, FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * _trianglesCount * sizeof(GLfloat), _normals, GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, _cboID); glBufferData(GL_ARRAY_BUFFER, FLOAT_PER_VERTEX * VERTEX_PER_TRIANGLE * _trianglesCount * sizeof(GLubyte), _colors, GL_DYNAMIC_DRAW); }
void AudioBody::setPosition (const Vector3& v) { if (destroyed) THROW_DEAD(className); if (ambient) return; position = v; updatePositions(); }
EqTitleBar::EqTitleBar(QWidget *parent) : PixmapWidget(parent) { m_volumeBar = 0; m_balanceBar = 0; m_shade2 = 0; m_left = 0; m_right = 0; m_shaded = false; m_align = false; m_skin = Skin::instance(); m_eq = parentWidget(); m_mw = qobject_cast<MainWindow*>(m_eq->parent()); m_close = new Button(this, Skin::EQ_BT_CLOSE_N, Skin::EQ_BT_CLOSE_P, Skin::CUR_EQCLOSE); connect(m_close, SIGNAL(clicked()),m_eq, SIGNAL(closed())); m_shade = new Button(this, Skin::EQ_BT_SHADE1_N, Skin::EQ_BT_SHADE1_P, Skin::CUR_EQNORMAL); connect(m_shade, SIGNAL(clicked()), SLOT(shade())); QSettings settings(Qmmp::configFile(), QSettings::IniFormat); if (settings.value("Skinned/eq_shaded", false).toBool()) shade(); m_align = true; setActive(false); setCursor(m_skin->getCursor(Skin::CUR_EQTITLE)); connect(m_skin, SIGNAL(skinChanged()), SLOT(updateSkin())); updatePositions(); }
/** Intializes the PartResizerWidget @param d the Device the Partition is on @param p the Partition to show and/or resize @param minFirst the minimum value for the first sector @param maxLast the maximum value for the last sector */ void PartResizerWidget::init(Device& d, Partition& p, qint64 minFirst, qint64 maxLast, bool read_only, bool move_allowed) { setDevice(d); setPartition(p); setMinimumFirstSector(minFirst); setMaximumLastSector(maxLast); setReadOnly(read_only); setMoveAllowed(move_allowed); setMinimumLength(qMax(partition().sectorsUsed(), partition().minimumSectors())); setMaximumLength(qMin(totalSectors(), partition().maximumSectors())); // set margins to accommodate to top/bottom button asymmetric layouts QStyleOptionButton bOpt; bOpt.initFrom(this); QRect buttonRect(style()->subElementRect(QStyle::SE_PushButtonContents, &bOpt)); int asym = (rect().bottom() - buttonRect.bottom()) - (buttonRect.top() - rect().top()); if (asym > 0) setContentsMargins(0, asym, 0, 0); else setContentsMargins(0, 0, 0, asym); if (!readOnly()) { QPixmap pixmap(handleWidth(), handleHeight()); pixmap.fill(Qt::transparent); QPainter p(&pixmap); QStyleOption opt; opt.state |= QStyle::State_Horizontal; opt.rect = pixmap.rect().adjusted(0, 2, 0, -2); style()->drawControl(QStyle::CE_Splitter, &opt, &p, this); leftHandle().setPixmap(pixmap); rightHandle().setPixmap(pixmap); leftHandle().setFixedSize(handleWidth(), handleHeight()); rightHandle().setFixedSize(handleWidth(), handleHeight()); } delete m_PartWidget; m_PartWidget = new PartWidget(this, &partition()); if (!readOnly()) { leftHandle().setCursor(Qt::SizeHorCursor); rightHandle().setCursor(Qt::SizeHorCursor); } if (moveAllowed()) partWidget().setCursor(Qt::SizeAllCursor); partWidget().setToolTip(QString()); updatePositions(); }
int ofxTextObject::wrapTextX(float lineWidth) { columnWidth = lineWidth; //soso if (words.size() > 0) { float runningWidth = 0.0f; lines.clear(); bool newLine = true; lineBlock tmpLine; tmpLine.wordsID.clear(); int activeLine = 0; for(int i=0;i < words.size(); i++) { runningWidth += (words[i].width); //soso - check for new line word if (words[i].isNewLine) { //printf("New Line \n"); newLine = true; lines.push_back(tmpLine); tmpLine.wordsID.clear(); //runningWidth = 0.0f + words[i].width; runningWidth = 0.0f + scaleFactor*words[i].width; //Account for scaleFactor. activeLine++; } //else if (runningWidth <= (lineWidth)) { else if ((scaleFactor*runningWidth) <= lineWidth) { //Account for scaleFactor here when wrapping lines. newLine = false; } else { //printf("Wrap New Line \n"); newLine = true; lines.push_back(tmpLine); tmpLine.wordsID.clear(); runningWidth = 0.0f + words[i].width; activeLine++; } tmpLine.wordsID.push_back(i); } //Push in the final line. lines.push_back(tmpLine); _trimLineSpaces(); //Trim the leading and trailing spaces. } updatePositions(lineWidth); //All other wrap calls eventually boil down to this wrap method, so we only have to call this once here. renderDirty = true; return lines.size(); }
void GraphicNetCloud::addNode(GraphicNetNode* node){ if(!nodes.contains(node)){ nodes.push_back(node); node->setParentItem(this); } updatePositions(); }
bool playGame(Affichage A, Damier *map, Snake *snake, Sound sound) { int end = 0; bool win = FALSE; Position newPos = initPosition(); Input input = initInput(); Chrono chrono = initChrono(); Timer timer = initTimer(); setProiesToMap(map); drawTile(A, TILE_TITLE); drawTextChrono(chrono, A); drawMap(A, *map, newPosition(MAXCASES/2 + 3,MAXCASES/2), *snake); startChrono(&chrono); while (1) { setTimer(&timer); newPos = updatePositions(map, snake, &input); if (input.end) break; if (testPosMap(newPos)) { end = addPositionSnake(map, snake, newPos, sound); if (end) { win = FALSE; break; } } setPositionsToMap(map, snake); drawChrono(chrono, A); drawMap(A, *map, newPos, *snake); if(endChrono(chrono)) { win = FALSE; break; } if (endGame(map)) { win = TRUE; break; } reguleFPS(&timer); } deleteChrono(&chrono); return win; }
void Sprite::setTextureRect(const IntRect& rectangle) { if (rectangle != m_textureRect) { m_textureRect = rectangle; updatePositions(); updateTexCoords(); } }
void takeCard(Card& c){ Card * temp = new Card(c); Cards.push_back(temp); Cards.back()->rotate((horizontal?0.0f:90.0f)); Cards.back()->setFaceUp(visible); std::sort(Cards.begin(), Cards.end(), CardCompare(kozer)); scale(area); updatePositions(); }
void GraphicNetCloud::removeNode(GraphicNetNode* node){ nodes.removeAt(nodes.indexOf(node)); if(node->parentItem() == this){ qDebug() << "GraphicNetCloud::removeNode - Cloud " << address.toString().c_str() <<" parent of node"; node->setParentItem(NULL); } updatePositions(); }
void CListBox::reset() { size_t current = first; for (std::list<CIntObject*>::iterator it = items.begin(); it!=items.end(); it++) { deleteItem(*it); *it = createItem(current++); } updatePositions(); }
void PatchMap::fill(){ if(lut.isEmpty()) std::cout << "Warning: no fragments available. Ensure maps are in the correct input location.\n"; for(unsigned int i = 0; i < xTiles * yTiles; ++i) step(); updatePositions(); updateEdges(); };
void ParticleEmitter::update(float time_delta) { spawnParticles(time_delta); updateLives(time_delta); updatePositions(time_delta); updateRotations(time_delta); for (auto* module : m_modules) { module->update(time_delta); } }
void KBBGraphicsItemCursor::setBoardSize(const int columns, const int rows) { m_columns = columns; m_rows = rows; m_boxPosition = 0; m_borderPosition = NO_POSITION; updatePositions(); hide(); }