自学教程：C++ updateFrame函数代码示例

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 OVDvoid 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);   }}

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 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;}

	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);  }}