void
MainWorkflow::renderOneFrame()
{
for ( unsigned int i = 0; i < Workflow::NbTrackType; ++i )
m_tracks[i]->renderOneFrame();
nextFrame( Workflow::VideoTrack );
nextFrame( Workflow::AudioTrack );
}
void LayerTreeHostGtk::RenderFrameScheduler::renderFrame()
{
m_fireTime = monotonicallyIncreasingTime();
if (!m_renderer() || m_timer.isActive())
return;
nextFrame();
}
void Animator::update() {
speedCount++;
if (speedCount >= frameTick) {
nextFrame();
speedCount = 0;
}
}
void LayerTreeHostGtk::RenderFrameScheduler::start()
{
if (m_timer.isActive())
return;
m_fireTime = 0;
nextFrame();
}
void ImageViewer::stopAnimation() {
if(movie) {
animationTimer->stop();
disconnect(animationTimer, SIGNAL(timeout()), this, SLOT(nextFrame()));
movie->jumpToFrame(0);
}
}
void Sensor::update() {
if (Serial1.available() > 0) {
input = Serial1.read();
if( input == 0 || input == 1 ) {
if (forward = (input == 0)) {
calcTiming();
nextFrame();
frameCounter++;
} else {
frameCounter--;
}
} else if ( input == 2) {
if (forward) nextSceneCounter++;
if (nextSceneCounter >= nextSceneThreshold) {
nextScene();
nextSceneCounter = 0;
}
} else if ( input == 3 ) {
if (forward) endCounter++; else startCounter++;
if (endCounter >= endThreshold) {
endFilm();
endCounter = startCounter = 0;
} else if (startCounter >= startThreshold) {
startFilm();
endCounter = startCounter = 0;
}
}
}
}
AnimationScene::AnimationScene(QObject *parent) : QGraphicsScene(parent)
{
//ImageFrame = new QGraphicsPixmapItem;
x=0; y=0, dir=1;
FullFrames = AniFrames;
framesTable = framesX;
mCurFrN = 0;
mPos = QPoint(0,0);
mSpriteImage = MW::p->x_imageSprite;
NoAnimate = QPixmap(":/images/NoAni.png");
draw();
currentImage = NoAnimate;
ImageFrame.setPixmap( currentImage );
addItem(&ImageFrame);
ImageFrame.setPos(100, 200);
ImageFrame.setZValue(1.0);
GRound.setRect(1,1,200,20);
GRound.setBrush(QBrush(Qt::lightGray));
GRound.setPen( QPen(QBrush(Qt::gray),2,Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin ) );
GRound.setZValue(-5.0);
addItem(&GRound);
timer.setInterval(128);
connect(
&timer, SIGNAL(timeout()),
this,
SLOT( nextFrame() ) );
}
bool AGui::run() {
if(!init()) {
return false;
}
#ifdef __unix__
signal(SIGINT,quit_signal_handler); // listen for ctrl-C
#endif
double t0 = timestamp();
int numFrames = 0;
while (nextFrame()) {
if (numFrames >= 1000) {
numFrames = 0;
t0 = timestamp();
}
numFrames++;
cout << "FPS: " << numFrames/(timestamp()-t0) << endl;
if (quit_signal) exit(0);
int key;
if (fps <= 0) {
key = waitKey(0);
} else {
key = waitKey((int) 1000.0 / fps);
}
if((key & 0xFF) == 27) {
break;
}
}
return true;
}
// Called once every frame of the game.
void AnimatedSprite::update()
{
World* world = AssetManager::getAssetManager()->getWorld();
// Update the position of the sprite:
float x = body->GetPosition().x * SCALE - (spriteSheetData.drawWidth / 2) - world->getXOffset();
float y = body->GetPosition().y * SCALE - (spriteSheetData.drawHeight / 2) - world->getYOffset();
if(this->getScale().x == -1)
x += getTextureRect().width;
this->setPosition(x, y);
// Stop the timer
timer->Stop();
timeSinceLastFrame += timer->GetElapsedAsSeconds();
// When the timer reaches the right amount of time, switch frames.
if(timeSinceLastFrame > spriteSheetData.timeBetweenFrames )
{
nextFrame();
timeSinceLastFrame = 0;
}
timer->Start();
}
/*
=======================================================================================================================
=======================================================================================================================
*/
int main(int argc, char **argv)
{
/*~~~~~~*/
/* seed the rand function */
time_t t;
/*~~~~~~*/
srand(time(0));
/* initialise glut and a window */
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
glutInitWindowPosition(100, 100);
/* create a window and initialise the program */
glutCreateWindow("Spin the Teapot: Can you guess where it lands next?");
init();
/* set callback functions */
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(input);
nextFrame(0);
glutMainLoop();
return 0;
}
void
QvisVCRControl::b4_clicked()
{
// If the stop button is not active, make it active and turn off the
// button that was last active.
if(activeButton != 2)
{
buttons[activeButton]->setDown(false);
activeButton = 2;
buttons[activeButton]->setDown(true);
}
buttons[1]->blockSignals(true);
buttons[1]->setChecked(false);
buttons[1]->blockSignals(false);
buttons[2]->blockSignals(true);
buttons[2]->setChecked(true);
buttons[2]->blockSignals(false);
buttons[3]->blockSignals(true);
buttons[3]->setChecked(false);
buttons[3]->blockSignals(false);
#ifdef DEBUG_VCR
qDebug("nextFrame()");
#endif
emit nextFrame();
}
//--------------------------------------------------------------
void Sprite::draw() {
if(frames.empty()) {
return;
}
// animate frames?
if(bAnimate) {
// go to next frame if time has elapsed
if(ofGetElapsedTimeMillis() - timestamp > frames.at(currentFrame)->getFrameTime()) {
if(bForward) {
nextFrame();
}
else {
prevFrame();
}
timestamp = ofGetElapsedTimeMillis();
}
}
// draw frame(s)?
if(bVisible) {
if(bDrawAllLayers) {
for(unsigned int i = 0; i < frames.size(); ++i) {
DrawableFrame* f = frames.at(i);
f->draw(pos.x, pos.y);
}
}
else if(currentFrame >= 0 && currentFrame < (int) frames.size()) {
DrawableFrame* f = frames.at(currentFrame);
f->draw(pos.x, pos.y);
}
}
}
void MovementSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
{
(void)ev;
en.each<Position, Direction>([dt](entityx::Entity entity, Position &position, Direction &direction) {
position.x += direction.x * dt;
position.y += direction.y * dt;
if (entity.has_component<Animate>() && entity.has_component<Sprite>()) {
auto animate = entity.component<Animate>();
entity.component<Sprite>()->sprite =
(direction.x != 0) ? animate->nextFrame() : animate->firstFrame();
}
if (entity.has_component<Dialog>() && entity.component<Dialog>()->talking) {
direction.x = 0;
} else {
if (entity.has_component<Sprite>()) {
auto& fl = entity.component<Sprite>()->faceLeft;
if (direction.x != 0)
fl = (direction.x < 0);
}
if (entity.has_component<Wander>()) {
auto& countdown = entity.component<Wander>()->countdown;
if (countdown > 0) {
countdown--;
} else {
countdown = 5000 + randGet() % 10 * 100;
direction.x = (randGet() % 3 - 1) * 0.02f;
}
}
}
});
}
void ImageViewer::startAnimation() {
if(movie) {
stopAnimation();
connect(animationTimer, SIGNAL(timeout()), this, SLOT(nextFrame()));
startAnimationTimer();
}
}
static void ImplementUnlockPrimary()
{
if(primaryData)
{
int bufStride = primaryWidth * Blitter.GetBytesPerPixel();
{
VideoCaptureDataLock lock;
// convert from temp buffer to capture buffer
for(int y=0;y<captureHeight;y++)
{
unsigned char *src = primaryData + (captureHeight-1-y) * bufStride;
unsigned char *dst = captureData + y * captureWidth * 3;
Blitter.BlitOneLine(src,dst,captureWidth);
}
encoder->WriteFrame(captureData);
}
// copy from temp buffer to primary surface so user sees what's going on
for(int y=0;y<primaryHeight;y++)
memcpy(primaryLockPtr + y*primaryPitch,primaryData + y*bufStride,bufStride);
// free temp buffer again
delete[] primaryData;
primaryData = 0;
}
nextFrame();
}
void update()
{
if(bPaused)
return;
int time = timeGetTime() - timestampBegin + timestamp;
LONG currSample = AVIStreamTimeToSample(stream,time);
if(currSample >= numSamples)
currSample = numSamples-1;
for(LONG l = lastSample+1; l<= currSample; l++)
{
nextFrame();
decodeFrame();
if(lastSample == numSamples-1)
{
pause();
//err("movie finished playing");
break;
}
}
lastSample = currSample;
//render();
}
int nulVersion1FormatReader::firstFrame()
{
m_currentFrameIndex = 0;
fileStream.seekg(0,std::ios_base::beg);
nextFrame();
return currentFrame();
}
void PhMediaPanel::onNextFrame()
{
if(_clock) {
_clock->setRate(0);
_clock->setFrame(_clock->frame() + 1);
}
emit nextFrame();
}
void Explosion::animate() {
sf::IntRect nextFrame(frameNumber * 32, 0, 32, 32);
this->setTextureRect(nextFrame);
++frameNumber;
if (frameNumber >= 7) {
done = true;
}
}
void LimbsWeightDialog::on_copyToNextPushButton_clicked()
{
int value = _weights[currentFrame];
currentFrame++;
emit nextFrame();
_weights[currentFrame] = value;
initComponents();
}
DSerialFrameMovie::DSerialFrameMovie(QWidget *parent):
DPushButton("",parent)
{
m_Timer=new QTimer(this);
connect(m_Timer,SIGNAL(timeout()),this,SLOT(nextFrame()));
m_FrameIndex = 0;
}
void SpriteImage::nextFrame(float second)
{
if (_time + second < TIMEMANAGER->getWorldTime())
{
_time = TIMEMANAGER->getWorldTime();
nextFrame();
}
}
KateTextAnimation::~KateTextAnimation()
{
// if still running, we need to update the view a last time to avoid artifacts
if (m_timeLine->state() == QTimeLine::Running) {
m_timeLine->stop();
nextFrame(0.0);
}
}
void AnimatedSprite::update()
{
if(ticksInFrame > ticksForFrame)
{
nextFrame();
}
ticksInFrame++;
}
/**
* @brief Produce a new frame at every keystroke
*
* @return Returns when no more frame are available. The value
* is always true.
*
*/
bool run(){
init();
while (nextFrame()){
waitKey(0);
}
return true;
}
PlayerWidget::PlayerWidget(QWidget *parent) :
QWidget(parent)
{
infoLabel = new QLabel;
imageLabel = new QLabel;
playPauseButton = new QPushButton;
stopButton = new QPushButton;
positionSlider = new QSlider(Qt::Horizontal);
playTimer = new QTimer;
fpsSpinBox = new MyDoubleSpinBox;
currentIndex = 0;
playTimer->setInterval(30);
playPauseButton->setEnabled(true);
playPauseButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
stopButton->setEnabled(true);
stopButton->setIcon(style()->standardIcon(QStyle::SP_MediaStop));
imageLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
imageLabel->setAlignment(Qt::AlignCenter);
fpsSpinBox->setMinimum(0.01);
fpsSpinBox->setMaximum(100);
fpsSpinBox->setDecimals(2);
fpsSpinBox->setValue(30);
QLabel *fpsLabel = new QLabel("FPS");
QHBoxLayout *controlLayout = new QHBoxLayout;
controlLayout->setMargin(5);
controlLayout->addWidget(stopButton);
controlLayout->addWidget(playPauseButton);
controlLayout->addWidget(positionSlider);
controlLayout->addWidget(fpsLabel);
controlLayout->addWidget(fpsSpinBox);
controlLayout->addWidget(infoLabel);
QBoxLayout *layout = new QVBoxLayout;
layout->setMargin(0);
layout->addWidget(imageLabel);
layout->addLayout(controlLayout);
layout->setStretch(0, 1);
setLayout(layout);
// QDir imageDir = QDir(gPar->Get<QString>("anim_flight_dir"));
// QStringList imageFileExtensions;
// imageFileExtensions << "*.jpg" << "*.jpeg" << "*.png";
// imageDir.setNameFilters(imageFileExtensions);
// imageFiles = imageDir.entryList(QDir::NoDotAndDotDot | QDir::Files);
connect(positionSlider, SIGNAL(sliderMoved(int)), this, SLOT(setPosition(int)));
connect(playPauseButton, SIGNAL(clicked()), this, SLOT(playPause()));
connect(stopButton, SIGNAL(clicked()), this, SLOT(stop()));
connect(playTimer, SIGNAL(timeout()), this, SLOT(nextFrame()));
connect(fpsSpinBox, SIGNAL(valueChanged(double)), this, SLOT(setFPS(double)));
QApplication::connect(&imageFolderWatcher,
SIGNAL(directoryChanged(const QString&)),
this,
SLOT(updateFromFolder()));
}
/*
* Frame manager for the screensaver
*/
void tickScreensaver()
{
if (tickCount == 0) {
nextFrame();
tickCount = TICKS_PER_FRAME;
} else {
tickCount--;
}
}
EuphoriaWidget::EuphoriaWidget( QWidget* parent, const char* name )
: QGLWidget(parent, name), texName(0), _wisps(0), _backwisps(0),
feedbackmap(0), feedbacktex(0)
{
setDefaults( Regular );
_frameTime = 1000 / 60;
_timer = new QTimer( this );
connect( _timer, SIGNAL(timeout()), this, SLOT(nextFrame()) );
}
Profiler::~Profiler() {
// Wait for all queries to complete
nextFrame();
// Delete all queries
if (m_queryFreelist.size() > 0) {
glDeleteQueries(m_queryFreelist.size(), m_queryFreelist.getCArray());
m_queryFreelist.clear();
}
}
void TimedAnimation::processTimer(float ticks)
{
if(frame_delay<1) return; //Idling animation
ticks_left -= fabs(ticks);
while(ticks_left <= 0.0f)
{
nextFrame();
ticks_left+=frame_delay;
}
}
