void MadsPlayer::idle() {
if (_direction != _newDirection) {
// The direction has changed, so reset for new direction
dirChanged();
return;
}
SpriteAsset &spriteSet = _madsVm->scene()->_spriteSlots.getSprite(_spriteListStart + _spriteListIdx);
assert(spriteSet._charInfo);
if (spriteSet._charInfo->_numEntries == 0)
// No entries, so exit immediately
return;
int frameIndex = ABS(_frameListIndex);
int direction = (_frameListIndex < 0) ? -1 : 1;
if (frameIndex >= spriteSet._charInfo->_numEntries)
// Reset back to the start of the list
_frameListIndex = 0;
else {
_frameNum += direction;
_forceRefresh = true;
if (spriteSet._charInfo->_frameList2[frameIndex] < _frameNum) {
_unk3 = _unk2;
updateFrame();
}
if (spriteSet._charInfo->_frameList[frameIndex] < _frameNum) {
_unk3 = _unk2;
updateFrame();
}
}
}
void AnimationViewControl::notifyMouseButtonClick(MyGUI::Widget* _sender)
{
if (_sender == mButtonPlay)
{
mPlay = !mPlay;
mButtonPlay->setStateSelected(!mPlay);
if (!mPlay)
updateSelectedFrame();
}
else if (_sender == mButtonLeft)
{
if (mAnimation.getFrames().size() != 0 && !mPlay)
{
mCurrentFrame += mAnimation.getFrames().size();
mCurrentFrame --;
updateFrame();
}
}
else if (_sender == mButtonRight && !mPlay)
{
if (mAnimation.getFrames().size() != 0)
{
mCurrentFrame ++;
updateFrame();
}
}
}
// emit updateFrame() to show/hide OVD
void FxPage::videoFilterSelected( Clip *c, int index )
{
emit currentFilterChanged( 0 );
if ( currentEffectsWidget ) {
delete currentEffectsWidget;
currentEffectsWidget = NULL;
effectsWidgetLayout = NULL;
}
if ( !c || index < 0 || index >= c->videoFilters.count() ) {
emit updateFrame();
return;
}
currentEffectsWidget = new QWidget();
effectsWidgetLayout = new QGridLayout( currentEffectsWidget );
FilterWidget *fw = new FilterWidget( currentEffectsWidget, c, c->videoFilters.at( index ) );
connect( fw, SIGNAL(updateFrame()), this, SIGNAL(updateFrame()) );
connect( fw, SIGNAL(editAnimation(FilterWidget*,ParameterWidget*,Parameter*)), this, SIGNAL(editAnimation(FilterWidget*,ParameterWidget*,Parameter*)) );
connect( fw, SIGNAL(compileShaderRequest(ThumbRequest)), this, SIGNAL(compileShaderRequest(ThumbRequest)) );
connect( fw, SIGNAL(paramUndoCommand(QSharedPointer<Filter>,Parameter*,QVariant,QVariant)), this, SIGNAL(paramUndoCommand(QSharedPointer<Filter>,Parameter*,QVariant,QVariant)) );
connect( fw, SIGNAL(reloadCurrentFilter()), videoGraph, SLOT(reloadCurrentFilter()) );
connect( this, SIGNAL(ovdValueChanged(ParameterWidget*)), fw, SLOT(ovdValueChanged(ParameterWidget*)) );
effectsWidgetLayout->addWidget( fw, 0, 1 );
effectsWidgetLayout->setRowStretch( 1, 1 );
videoEffectsWidget->setWidget( currentEffectsWidget );
emit updateFrame();
}
void MiniViewContainer::setView(QGraphicsView * view)
{
QGraphicsView * oldView = m_miniView->view();
if (oldView == view) return;
if (oldView != NULL) {
disconnect(oldView->horizontalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(updateFrame()));
disconnect(oldView->verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(updateFrame()));
disconnect(oldView->scene(), SIGNAL(sceneRectChanged(QRectF)), this, SLOT(updateFrame()));
disconnect(oldView, SIGNAL(resizeSignal()), this, SLOT(updateFrame()));
disconnect(m_frame, SIGNAL(scrollChangeSignal(double, double)), oldView, SLOT(navigatorScrollChange(double, double)));
}
void MovieGlHap::draw()
{
updateFrame();
mObj->lock();
if( mObj->mTexture ) {
Rectf centeredRect = Rectf( mObj->mTexture->getCleanBounds() ).getCenteredFit( app::getWindowBounds(), true );
gl::color( Color::white() );
auto drawRect = [&]() {
gl::ScopedTextureBind tex( mObj->mTexture );
float cw = mObj->mTexture->getCleanWidth();
float ch = mObj->mTexture->getCleanHeight();
float w = mObj->mTexture->getWidth();
float h = mObj->mTexture->getHeight();
gl::drawSolidRect( centeredRect, vec2( 0, 0 ), vec2( cw / w, ch / h ) );
};
if( isHapQ() ) {
gl::ScopedGlslProg bind( MovieGlHap::Obj::sHapQShader );
drawRect();
} else {
gl::ScopedGlslProg bind( mObj->mDefaultShader );
drawRect();
}
}
mObj->unlock();
}
void ModelMaker::on_threshbar_sliderMoved(int position)
{
QString lab = QString::number(position);
ui->threshlabel->setText(lab);
subThreshold=position;
updateFrame();
}
//--------------------------------------------------------------
void testApp::update(){
bool bNewFrame = false;
vidGrabber.grabFrame();
bNewFrame = vidGrabber.isFrameNew();
if (bNewFrame) {
color.setFromPixels(vidGrabber.getPixels(), vw,vh, OF_IMAGE_COLOR);
if (bLearnBakground == true) {
bgImgColor = color;
bLearnBakground = false;
}
if(bDrawLines)
blobInspector.capture(&color,&bgImgColor);
// Captura de l' objecte 2D
if(bTakeB2DShot && !bCaptured)
{
bCaptured = true;
bTakeB2DShot = false;
images.capture(&color,&bgImgColor);
images.OrderSkins();
for(int i=0; i < images.skins.size(); i++)
{
pieceInfo piece;
piece.pos = images.skins[i].posSkin;
piece.ang = 0.0;
// add piece position to frame
frame.push_back(piece);
bDraggable.push_back(true);
}
}
}
if(bCaptured)
{
for (int i = 0; i < images.getNumberSkins(); i++)
{
images.setPosition(i, frame[i].pos);
images.setRotation(i, frame[i].ang);
}
}
if(bPlay)
{
updateFrame(XML.getNextFrame());
if (XML.getCurrentFrame()==XML.getNumFrames()-1)
bPlay=false;
}
}
bool EngineManager::updateUnitily()
{
updateFrame();
renderFrame();
presentFrame();
return !isExitRequested();
}
int main(int argc, char **argv){
ros::init(argc, argv, "tracking_viewer");
//ros::NodeHandle n("~");
ros::NodeHandle n;
// setup window and mouse interaction
cv::namedWindow("Tracking Window", 0 );
cv::setMouseCallback("Tracking Window", onMouse, 0 );
std::string topic = "/opencv_cam/camera";
image_transport::ImageTransport transport(n);
image_transport::Subscriber image_sub = transport.subscribe(topic.c_str(), 1, &RosTLD::imageCallback, main);
//ros::Subscriber imu_sub = n.subscribe("imu", 100, &AHRS_Filter::callback,this);
ros::Subscriber tracker_sub = n.subscribe("target", 100, trackerCallback);
ros::Rate r(30); // run at 30 Hz
while(ros::ok()){
if(frame.data && !paused){
updateFrame(frame);
cv::imshow("Tracking Window", frame );
}
handleKeyboard();
ros::spinOnce();
r.sleep();
}
return 0;
}
FrameInfo* TFDisplay::createFrame(const std::string& frame)
{
FrameInfo* info = new FrameInfo;
frames_.insert( std::make_pair( frame, info ) );
info->name_ = frame;
info->axes_ = new ogre_tools::Axes( scene_manager_, axes_node_, 0.2, 0.02 );
info->axes_->setUserData( Ogre::Any( (void*)this ) );
info->axes_->getSceneNode()->setVisible( show_axes_ );
info->name_text_ = new ogre_tools::MovableText( frame, "Arial", 0.1 );
info->name_text_->setTextAlignment(ogre_tools::MovableText::H_CENTER, ogre_tools::MovableText::V_BELOW);
info->name_node_ = names_node_->createChildSceneNode();
info->name_node_->attachObject( info->name_text_ );
info->name_node_->setVisible( show_names_ );
info->parent_arrow_ = new ogre_tools::Arrow( scene_manager_, arrows_node_, 1.0f, 0.01, 1.0f, 0.08 );
info->parent_arrow_->getSceneNode()->setVisible( false );
info->category_ = property_manager_->createCategory( info->name_, property_prefix_ + info->name_, frames_category_, this );
info->parent_property_ = property_manager_->createProperty<StringProperty>( "Parent", property_prefix_ + info->name_, boost::bind( &FrameInfo::getParent, info ),
StringProperty::Setter(), info->category_, this );
info->position_property_ = property_manager_->createProperty<Vector3Property>( "Position", property_prefix_ + info->name_, boost::bind( &FrameInfo::getPositionInRobotSpace, info ),
Vector3Property::Setter(), info->category_, this );
info->orientation_property_ = property_manager_->createProperty<QuaternionProperty>( "Orientation", property_prefix_ + info->name_, boost::bind( &FrameInfo::getOrientationInRobotSpace, info ),
QuaternionProperty::Setter(), info->category_, this );
updateFrame( info );
return info;
}
void Entity::tick(sf::Time delta)
{
// Continue moving towards the tile position, if needed
if(!positionMatchesTilePosition())
{
// TODO: Float rounding issues?
float deltaPos = delta.asSeconds() * 120.0;
float needToMove = 0.0;
if(position.x < tilePosition.x * 32.0)
{
if(position.x + deltaPos > tilePosition.x * 32.0)
{
needToMove = tilePosition.x * 32.0 - position.x;
}
else
{
needToMove = deltaPos;
}
position.x += needToMove;
}
else if(position.x > tilePosition.x * 32)
{
if(position.x - deltaPos < tilePosition.x * 32.0)
{
needToMove = position.x - tilePosition.x * 32.0;
}
else
{
needToMove = deltaPos;
}
position.x -= needToMove;
}
else if(position.y < tilePosition.y * 32)
{
if(position.y + deltaPos > tilePosition.y * 32.0)
{
needToMove = tilePosition.y * 32.0 - position.y;
}
else
{
needToMove = deltaPos;
}
position.y += needToMove;
}
else if(position.y > tilePosition.y * 32)
{
if(position.y - deltaPos < tilePosition.y * 32.0)
{
needToMove = position.y - tilePosition.y * 32.0;
}
else
{
needToMove = deltaPos;
}
position.y -= needToMove;
}
updateFrame(needToMove);
}
}
void UpdateModule::update(float dt){
float totaltime=dt+deltaframetime;
if (totaltime>frametime) {
int updatetime=totaltime/frametime;
for (int i=0; i<updatetime; i++) {
updateFrame(frametime);
}
deltaframetime=0;
totaltime-=updatetime*frametime;
}
if (totaltime>0) {
deltaframetime+=totaltime;
}
}
StereoCalibrationDialog::StereoCalibrationDialog(QWidget *parent, int leftCamId, int rightCamId, QString calibDir) :
QDialog(parent),
ui(new Ui::StereoCalibrationDialog)
{
ui->setupUi(this);
this->leftCamId = leftCamId;
this->rightCamId = rightCamId;
this->calibDir = calibDir;
this->setWindowTitle("Stereo Camera calibration");
addDirectory(calibDir);
createCalibDirs();
captureLeft = cv::VideoCapture(this->leftCamId);
if(!captureLeft.isOpened())
{
captureLeft.open(this->leftCamId);
}
captureRight = cv::VideoCapture(this->rightCamId);
if(!captureRight.isOpened())
{
captureRight.open(this->rightCamId);
}
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(updateFrame()));
imageCounter = 0;
patternSize.height = 0;
patternSize.width = 0;
squareSize = 0.f;
}
void AnimationViewControl::rebuildAnimations()
{
mAnimation.setTextureName("");
mAnimation.clearFrames();
mCurrentFrame = 0;
mTime = 0;
if (mParentData != nullptr)
{
mAnimation.setTextureName(mParentData->getParent()->getPropertyValue("Texture"));
mAnimation.setSize(mParentData->getParent()->getPropertyValue<MyGUI::IntCoord>("Size").size());
mAnimation.setRate(mParentData->getPropertyValue<float>("Rate"));
for (Data::VectorData::const_iterator child = mParentData->getChilds().begin(); child != mParentData->getChilds().end(); child ++)
{
size_t count = (*child)->getPropertyValue<size_t>("Count");
MyGUI::IntPoint point = (*child)->getPropertyValue<MyGUI::IntPoint>("Point");
mAnimation.addFrame(point, count);
}
if (!mPlay)
updateSelectedFrame();
}
mImage->setImageTexture(mAnimation.getTextureName());
if (mAnimation.getFrames().size() == 0)
mImage->setImageCoord(MyGUI::IntCoord());
else
updateFrame();
mFrameInfo->setCaption(MyGUI::utility::toString(mCurrentFrame, " : ", mAnimation.getFrames().size()));
updateImageCoord();
}
void LiveStream::start()
{
if (state() >= Connecting)
return;
if (state() == StreamOffline)
{
m_autoStart = true;
return;
}
connect(m_renderTimer, SIGNAL(timeout()), SLOT(updateFrame()), Qt::UniqueConnection);
m_frameInterval.start();
if (m_thread)
m_thread->stop();
m_thread.reset(new LiveStreamThread());
connect(m_thread.data(), SIGNAL(fatalError(QString)), this, SLOT(fatalError(QString)));
m_thread->start(url());
updateSettings();
setState(Connecting);
}
void as::AnimatedSprite::tick( sf::Time deltaTime ) {
// if paused or we have less than one frame to display on the current animation.
if ( m_paused || m_currentAnimation->m_frames.size() <= 1 ) {
return;
}
m_currentTime += deltaTime;
updateFrameIndex();
updateFrame();
}
gboolean onSlide(GtkRange *range, gpointer user_data) {
udata *dat=(udata *)user_data;
UNUSED(range);
dat->index=gtk_range_get_value (GTK_RANGE(dat->hSlider))-1;
updateFrame(user_data,1);
updateStatusBar(user_data);
return TRUE;
}
gboolean onZoomOnePress (GtkToolButton * btn, gpointer user_data) {
udata *dat=(udata *)user_data;
UNUSED(btn);
dat->zoom=1.0;
updateFrame(user_data,-1);
updateStatusBar(user_data);
return TRUE;
}
void ObjectSprite::rotateFrame()
{
frame++;
if ( frame >= maxFrame )
{
frame = 0;
}
updateFrame();
}
void CameraView::connectStream()
{
// Create processing thread
processingThread = new ProcessingThread(sharedImageBuffer, tabId,id);
// Setup signal/slot connections
connect(processingThread, SIGNAL(newFrame(QImage)), this, SLOT(updateFrame(QImage)));
connect(processingThread, SIGNAL(updateStatisticsInGUI(struct ThreadStatisticsData)), this, SLOT(updateProcessingThreadStats(struct ThreadStatisticsData)));
connect(captureThread, SIGNAL(updateStatisticsInGUI(struct ThreadStatisticsData)), this, SLOT(updateCaptureThreadStats(struct ThreadStatisticsData)));
connect(this, SIGNAL(setROI(QRect)), processingThread, SLOT(setROI(QRect)));
// Only enable ROI setting/resetting if frame processing is enabled
connect(ui->frameLabel, SIGNAL(newMouseData(struct MouseData)), this, SLOT(newMouseData(struct MouseData)));
// Set initial data in processing thread
// emit setROI(QRect(0, 0, captureThread->getInputSourceWidth(), captureThread->getInputSourceHeight()));
// Start capturing frames from camera
captureThread->start((QThread::Priority)QThread::NormalPriority);
// Start processing captured frames (if enabled)
processingThread->start((QThread::Priority)QThread::TimeCriticalPriority);
// Setup imageBufferBar with minimum and maximum values
ui->imageBufferBar->setMinimum(0);
ui->imageBufferBar->setMaximum(sharedImageBuffer->maxSize());
// Enable/disable appropriate GUI items
//ui->imageProcessingMenu->setEnabled(enableFrameProcessing);
//ui->imageProcessingSettingsAction->setEnabled(enableFrameProcessing);
// Enable "Clear Image Buffer" push button
ui->clearImageBufferButton->setEnabled(true);
// Set text in labels
// ui->deviceNumberLabel->setNum(tabId);
ui->cameraResolutionLabel->setText(
QString::number(captureThread->getInputSourceWidth())+
QString("x")+
QString::number(captureThread->getInputSourceHeight())+
QString(" (")+
QString::number(ui->frameLabel->width())+
QString("x")+
QString::number(ui->frameLabel->height())+
QString(")")
);
// Set internal flag and return
isCameraConnected=true;
// Set frame label text
loadLinesSettings();
if(captureThread->getInputSourceWidth() > ui->frameLabel->width())
{
processingThread->resizeToFitWindow = true;
INFOMSG(("resizing to fit window"));
}
}
void TFDisplay::updateFrames()
{
typedef std::vector<std::string> V_string;
V_string frames;
tf_->getFrameStrings( frames );
S_FrameInfo current_frames;
{
V_string::iterator it = frames.begin();
V_string::iterator end = frames.end();
for ( ; it != end; ++it )
{
const std::string& frame = *it;
if ( frame.empty() )
{
continue;
}
FrameInfo* info = getFrameInfo( frame );
if (!info)
{
info = createFrame(frame);
}
else
{
updateFrame(info);
}
current_frames.insert( info );
}
}
{
S_FrameInfo to_delete;
M_FrameInfo::iterator frame_it = frames_.begin();
M_FrameInfo::iterator frame_end = frames_.end();
for ( ; frame_it != frame_end; ++frame_it )
{
if ( current_frames.find( frame_it->second ) == current_frames.end() )
{
to_delete.insert( frame_it->second );
}
}
S_FrameInfo::iterator delete_it = to_delete.begin();
S_FrameInfo::iterator delete_end = to_delete.end();
for ( ; delete_it != delete_end; ++delete_it )
{
deleteFrame( *delete_it );
}
}
causeRender();
}
VideoPlayer::VideoPlayer(QObject *parent, PlayList* playList,PboTexture* PBO) :
QObject(parent)
{
pList=playList;
pPBO=PBO;
pStopOnLastFrame=false;
pTimer.moveToThread(&pThread);
this->moveToThread(&pThread);
connect(&pTimer,SIGNAL(timeout()),this,SLOT(updateFrame()));
}
gl::TextureRef MovieGl::getTexture()
{
updateFrame();
lock();
gl::TextureRef result = mTexture;
unlock();
return result;
}
gl::TextureRef MovieGlHap::getTexture()
{
updateFrame();
mObj->lock();
auto texture = mObj->mTexture;
mObj->unlock();
return texture;
}
void TestStage::onUpdate( long time )
{
BaseClass::onUpdate( time );
int frame = time / gDefaultTickTime;
for( int i = 0 ; i < frame ; ++i )
tick();
updateFrame( frame );
}
void Predator::update(){
this->setZOrder(MapManager::getInstance()->_mapHeight - this->getPositionY());
updateAI();
if (!isMoving() \
&& GameManager::getInstance()->_gameState == (int)GameManager::GameState::IN_THE_GAME)
{
switch (_moveTrigger){
case CHARACTER_DIRECTION_DOWN:
if (moveDown() == true){
_state = (int)State::WALK;
_moveSpeed = PREDATOR_WALK_MOVE_SPEED;
}
break;
case CHARACTER_DIRECTION_LEFT:
if (moveLeft() == true){
_state = (int)State::WALK;
_moveSpeed = PREDATOR_WALK_MOVE_SPEED;
}
break;
case CHARACTER_DIRECTION_RIGHT:
if (moveRight() == true){
_state = (int)State::WALK;
_moveSpeed = PREDATOR_WALK_MOVE_SPEED;
}
break;
case CHARACTER_DIRECTION_UP:
if (moveUp() == true){
_state = (int)State::WALK;
_moveSpeed = PREDATOR_WALK_MOVE_SPEED;
}
break;
default:
break;
}
}
if (isMoving())
{
updateMove();
}
//若本帧不作任何移动
else
{
if (_state == (int)State::WALK)
{
_state = (int)State::STOP;
}
}
updateFrame();
}
LoadSpinner::LoadSpinner(QWidget *parent) :
QWidget(parent), m_startAngle(0), m_span(0), m_growing(true)
{
setAttribute(Qt::WA_TranslucentBackground);
setFixedSize(100, 100);
updateFrame();
// init timer
m_timer = new QTimer(this);
connect(m_timer, SIGNAL(timeout()), this, SLOT(rotate()));
m_timer->setInterval(30);
}
void GameAnimation::setAnim(int a) {
if (!loaded) return;
if (a == anim) return;
if (a < kca.aniCount)
anim = a;
else
anim = 0;
frame = 0;
curFrameTime = 0;
updateFrame();
}
void FxSettingsPage::clipSelected( ClipViewItem *clip )
{
currentClip = clip;
if ( currentEffectWidget ) {
delete currentEffectWidget;
currentEffectWidget = NULL;
effectWidgetLayout = NULL;
}
if ( currentEffectWidgetAudio ) {
delete currentEffectWidgetAudio;
currentEffectWidgetAudio = NULL;
effectWidgetLayoutAudio = NULL;
}
if ( clip && clip->getClip()->getTransition() ) {
videoFiltersCombo->setHidden( false );
audioFiltersCombo->setHidden( false );
setComboItems( clip->getClip()->getTransition() );
currentEffectWidget = new QWidget();
currentEffectWidget->setMinimumWidth( 150 );
effectWidgetLayout = new QGridLayout( currentEffectWidget );
effectWidgetLayout->setContentsMargins( 0, 0, 0, 0 );
FilterWidget *fw = new FilterWidget( currentEffectWidget, clip->getClip(), clip->getClip()->getTransition()->getVideoFilter() );
connect( fw, SIGNAL(updateFrame()), this, SIGNAL(updateFrame()) );
connect( fw, SIGNAL(paramUndoCommand(QSharedPointer<Filter>,Parameter*,QVariant,QVariant)), this, SIGNAL(paramUndoCommand(QSharedPointer<Filter>,Parameter*,QVariant,QVariant)) );
effectWidgetLayout->addWidget( fw, 0, 1 );
effectWidgetLayout->setRowStretch( 1, 1 );
videoWidget->setWidget( currentEffectWidget );
currentEffectWidgetAudio = new QWidget();
currentEffectWidgetAudio->setMinimumWidth( 150 );
effectWidgetLayoutAudio = new QGridLayout( currentEffectWidgetAudio );
effectWidgetLayoutAudio->setContentsMargins( 0, 0, 0, 0 );
fw = new FilterWidget( currentEffectWidgetAudio, clip->getClip(), clip->getClip()->getTransition()->getAudioFilter() );
connect( fw, SIGNAL(updateFrame()), this, SIGNAL(updateFrame()) );
connect( fw, SIGNAL(paramUndoCommand(QSharedPointer<Filter>,Parameter*,QVariant,QVariant)), this, SIGNAL(paramUndoCommand(QSharedPointer<Filter>,Parameter*,QVariant,QVariant)) );
effectWidgetLayoutAudio->addWidget( fw, 0, 1 );
effectWidgetLayoutAudio->setRowStretch( 1, 1 );
audioWidget->setWidget( currentEffectWidgetAudio );
}
void calcBallPosition(ball *aBall, paddle *p1, paddle *p2){
uint32_t collisionType = isCollision(aBall,p1,p2);
uint32_t blue = 0x000099; //black = 0x0;
if (collisionType == P1){
if( p1->direction == UP ) {
aBall->vY = aBall->vY - 1;
aBall->vX = -aBall->vX;
}
else if( p1->direction == DOWN ) {
aBall->vY = aBall->vY + 1;
aBall->vX = -aBall->vX;
}
else if( p1->direction == IDLE ) {
aBall->vY = aBall->vY;
aBall->vX = -aBall->vX;
}
}
else if (collisionType == P2){
if( p2->direction == UP ) {
aBall->vY = aBall->vY - 1;
aBall->vX = -aBall->vX;
}
else if( p2->direction == DOWN ) {
aBall->vY = aBall->vY + 1;
aBall->vX = -aBall->vX;
}
else if( p2->direction == IDLE ) {
aBall->vY = aBall->vY;
aBall->vX = -aBall->vX;
}
}
ballInBounds(aBall);
// erase ball
drawBall(blue,aBall);
// calculate new positions
aBall->x = aBall->x + aBall->vX;
aBall->y = aBall->y + aBall->vY;
updateFrame(p1->y, p2->y, aBall->x, aBall->y, aBall, p1, p2);
if ( !isXInBounds( aBall->x ) ) {
if ( aBall->vX == VEL_X ) {
p1->score = p1->score + 1;
} else p2->score = p2->score + 1;
initializeGame(aBall, p1, p2);
}
}
