Added QtFPSvsTIMEanimation to the project

Author: Karl Phillip Buhr

QtFPSvsTIMEAnimation/QtFPSvsTIMEanimation.pro

@@ -0,0 +1,16 @@
+QT += widgets
+
+SOURCES += \
+    main.cpp \
+    time_anim_improved.cpp \
+    fps_canvas.cpp \
+    fps_anim.cpp \
+    time_anim.cpp \
+    time_canvas.cpp
+
+HEADERS += \
+    time_anim_improved.h \
+    time_anim.h \
+    fps_canvas.h \
+    fps_anim.h \
+    time_canvas.h

QtFPSvsTIMEAnimation/aula15_animation.pro.user

@@ -0,0 +1,70 @@
+#include "fps_anim.h"
+
+#include <QTimer>
+
+
+FrameAnimation::FrameAnimation(QWidget* parent)
+: QWidget(parent)
+{
+    _max_fps = 60;
+    _counter = 0;
+
+    _black_canvas = new FpsCanvas((QFrame*)this);
+    _blue_canvas = new FpsCanvas((QFrame*)this, Qt::blue);
+    _red_canvas = new FpsCanvas((QFrame*)this, Qt::red);
+
+    _black_label = new QLabel(this);
+    _black_label->setText("60 FPS");
+    _blue_label = new QLabel(this);
+    _blue_label->setText("30 FPS");
+    _red_label = new QLabel(this);
+    _red_label->setText("10 FPS");
+
+    _h_layout = new QGridLayout(this);
+    _h_layout->addWidget(_black_canvas, 0, 0, 1, 1);
+    _h_layout->addWidget(_blue_canvas, 0, 1, 1, 1);
+    _h_layout->addWidget(_red_canvas, 0, 2, 1, 1);
+    _h_layout->addWidget(_black_label, 3, 0, 1, 1);
+    _h_layout->addWidget(_blue_label, 3, 1, 1, 1);
+    _h_layout->addWidget(_red_label, 3, 2, 1, 1);
+
+    _group_box = new QGroupBox(this);
+    _group_box->setTitle("Frame-based Animation");
+    _group_box->setLayout(_h_layout);
+
+    _main_layout = new QVBoxLayout(this);
+    _main_layout->addWidget(_group_box);
+    setLayout(_main_layout);
+
+    // Start timer
+    QTimer::singleShot(1000/_max_fps, this, SLOT(_tick()));
+}
+
+void FrameAnimation::_tick()
+{
+    /* Decide which canvas should be updated */
+
+    // 30 FPS canvas must be draw once every 2x
+    if (_counter % 2 == 0)
+        _blue_canvas->draw();
+
+    // 10 FPS canvas must be draw once every 6x
+    if (_counter % 10 == 0)
+        _red_canvas->draw();
+
+    _counter++;
+    _counter = _counter % 60; // Ranges from 0 to 59
+
+    // 60 FPS canvas must be draw every time, so we ignore _counter
+    _black_canvas->draw();
+
+    // Reset the timer
+    QTimer::singleShot(1000/_max_fps, this, SLOT(_tick()));
+}
+
+void FrameAnimation::reset()
+{
+    _black_canvas->reset();
+    _blue_canvas->reset();
+    _red_canvas->reset();
+}

QtFPSvsTIMEAnimation/fps_anim.cpp

@@ -0,0 +1,30 @@
+#pragma once
+#include "fps_canvas.h"
+
+#include <QHBoxLayout>
+#include <QWidget>
+#include <QGroupBox>
+#include <QLabel>
+
+
+class FrameAnimation : public QWidget
+{
+    Q_OBJECT
+public:
+    FrameAnimation(QWidget* parent = NULL);
+
+public slots:
+    void reset();
+
+private slots:
+    void _tick();
+
+private:
+    QGroupBox* _group_box;
+    QVBoxLayout* _main_layout;
+    QGridLayout* _h_layout;
+    FpsCanvas* _black_canvas, *_blue_canvas, *_red_canvas;
+    QLabel* _black_label, *_blue_label, *_red_label;
+    int _max_fps;
+    int _counter;
+};

QtFPSvsTIMEAnimation/fps_anim.h

@@ -0,0 +1,59 @@
+#include "fps_canvas.h"
+
+#include <QPainter>
+#include <QDebug>
+
+
+FpsCanvas::FpsCanvas(QFrame* parent, const QColor color)
+: QFrame(parent), _color(color)
+{
+    // Initialize class members
+    _x = _y = 50;
+    _dx = 2;
+    _dy = 1;
+    _sq_sz = 10;
+
+    // Set size of the canvas
+    setMinimumSize(175, 175);
+}
+
+void FpsCanvas::paintEvent(QPaintEvent* event)
+{
+    QFrame::paintEvent(event);
+
+    QPainter painter(this);
+
+    // Paint white background
+    painter.fillRect(0, 0, width(), height(), Qt::white);
+
+    // Paint black frame around the canvas
+    painter.setPen(Qt::black);
+    painter.drawRect(0, 0, width()-1, height()-1);
+
+    /* Move square */
+
+    _x += _dx;
+    _y += _dy;
+
+    if ( _x <= 0 || (_x >= (width()-1) - _sq_sz) )
+        _dx = -_dx;
+
+    if ( _y <= 0 || (_y >= (height()-1) - _sq_sz) )
+        _dy = -_dy;
+
+    // Draw square
+    painter.fillRect(_x, _y, _sq_sz, _sq_sz, _color);
+}
+
+void FpsCanvas::draw()
+{
+    // Trigger paintEvent()
+    repaint();
+}
+
+void FpsCanvas::reset()
+{
+    _x = _y = 50;
+    _dx = 2;
+    _dy = 1;
+}

QtFPSvsTIMEAnimation/fps_canvas.cpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <QFrame>
+
+
+class FpsCanvas : public QFrame
+{
+    Q_OBJECT
+public:
+    FpsCanvas(QFrame* parent = NULL, const QColor color = Qt::black);
+
+    void draw();
+    void reset();
+
+    void paintEvent(QPaintEvent* event);
+
+private:
+    QColor _color;
+    int _sq_sz;    
+    int _x, _y;
+    int _dx, _dy;
+};

QtFPSvsTIMEAnimation/fps_canvas.h

@@ -0,0 +1,45 @@
+/* This application is based on the following tutorial by Steven Lambert:
+ * "Why You Should be Using Time-based Animation and How to Implement it"
+ *     http://blog.sklambert.com/using-time-based-animation-implement/
+ */
+#include "fps_anim.h"
+#include "time_anim.h"
+#include "time_anim_improved.h"
+
+#include <QApplication>
+#include <QMainWindow>
+#include <QPushButton>
+#include <QVBoxLayout>
+
+
+int main(int argc, char* argv[])
+{
+    QApplication app(argc, argv);
+
+    QWidget window;
+    window.setWindowTitle("Frame-based VS Time-based Animation");
+
+    QPushButton reset_bt(&window);
+    reset_bt.setText("Reset");
+
+    FrameAnimation fps_widget(&window);
+    QObject::connect(&reset_bt, SIGNAL(clicked()), &fps_widget, SLOT(reset()));
+
+    TimeAnimation time_widget(&window);
+    QObject::connect(&reset_bt, SIGNAL(clicked()), &time_widget, SLOT(reset()));
+
+    TimeAnimationImproved time_imp_widget(&window);
+    QObject::connect(&reset_bt, SIGNAL(clicked()), &time_imp_widget, SLOT(reset()));
+
+    QVBoxLayout main_layout(&window);    
+    main_layout.setAlignment(Qt::AlignCenter);
+    main_layout.addWidget(&reset_bt, 0, Qt::AlignRight);
+    main_layout.addWidget(&fps_widget);
+    main_layout.addWidget(&time_widget);
+    main_layout.addWidget(&time_imp_widget);
+
+    window.setLayout(&main_layout);
+    window.show();
+
+    return app.exec();
+}

QtFPSvsTIMEAnimation/main.cpp

@@ -0,0 +1,95 @@
+#include "time_anim.h"
+
+#include <qDebug>
+
+
+TimeAnimation::TimeAnimation(QWidget* parent)
+: QWidget(parent)
+{
+    _max_fps = 60;
+    _counter = 0;
+    _last_time_60fps = _last_time_30fps = _last_time_10fps = QDateTime::currentMSecsSinceEpoch();
+
+    _black_canvas = new TimeCanvas((QFrame*)this, Qt::black);
+    _blue_canvas = new TimeCanvas((QFrame*)this, Qt::blue);
+    _red_canvas = new TimeCanvas((QFrame*)this, Qt::red);
+
+    _black_label = new QLabel(this);
+    _black_label->setText("60 FPS");
+    _blue_label = new QLabel(this);
+    _blue_label->setText("30 FPS");
+    _red_label = new QLabel(this);
+    _red_label->setText("10 FPS");
+
+    _h_layout = new QGridLayout(this);
+    _h_layout->addWidget(_black_canvas, 0, 0, 1, 1);
+    _h_layout->addWidget(_blue_canvas, 0, 1, 1, 1);
+    _h_layout->addWidget(_red_canvas, 0, 2, 1, 1);
+    _h_layout->addWidget(_black_label, 3, 0, 1, 1);
+    _h_layout->addWidget(_blue_label, 3, 1, 1, 1);
+    _h_layout->addWidget(_red_label, 3, 2, 1, 1);
+
+    _group_box = new QGroupBox(this);
+    _group_box->setTitle("Time-based Animation");
+    _group_box->setLayout(_h_layout);
+
+    _main_layout = new QVBoxLayout(this);
+    _main_layout->addWidget(_group_box);
+    setLayout(_main_layout);    
+
+    // Start timer
+    QTimer::singleShot(1000/_max_fps, this, SLOT(_tick()));
+}
+
+// TODO:  study how to remove cur_time_30fps
+void TimeAnimation::_tick()
+{
+    /* Decide which canvas should be updated */
+
+    qint64 now = QDateTime::currentMSecsSinceEpoch();
+
+    // 30 FPS canvas must be draw once every 2x
+    if (_counter % 2 == 0)
+    {
+        // Compute how much time passed since the last update        
+        qint64 passed = now - _last_time_30fps;
+        _last_time_30fps = now;
+
+        _blue_canvas->move(passed);
+        _blue_canvas->draw();
+    }
+
+    // 10 FPS canvas must be draw once every 6x
+    if (_counter % 10 == 0)
+    {
+        // Compute how much time passed since the last update        
+        qint64 passed = now - _last_time_10fps;
+        _last_time_10fps = now;
+
+        _red_canvas->move(passed);
+        _red_canvas->draw();
+    }
+
+    // 60 FPS canvas must be draw every time, so we ignore _counter
+    {
+        // Compute how much time passed since the last update
+        qint64 passed = now - _last_time_60fps;
+        _last_time_60fps = now;
+
+        _black_canvas->move(passed);
+        _black_canvas->draw();
+    }
+
+    ++_counter;
+    _counter = _counter % 60; // Ranges from 0 to 59
+
+    // Reset the timer
+    QTimer::singleShot(1000/_max_fps, this, SLOT(_tick()));
+}
+
+void TimeAnimation::reset()
+{
+    _black_canvas->reset();
+    _blue_canvas->reset();
+    _red_canvas->reset();
+}

QtFPSvsTIMEAnimation/time_anim.cpp

@@ -0,0 +1,31 @@
+#pragma once
+#include "time_canvas.h"
+
+#include <QHBoxLayout>
+#include <QWidget>
+#include <QGroupBox>
+#include <QLabel>
+
+
+class TimeAnimation : public QWidget
+{
+    Q_OBJECT
+public:
+    TimeAnimation(QWidget* parent = NULL);
+
+public slots:
+    void reset();
+
+private slots:
+    void _tick();
+
+private:
+    QGroupBox* _group_box;
+    QVBoxLayout* _main_layout;
+    QGridLayout* _h_layout;
+    TimeCanvas* _black_canvas, *_blue_canvas, *_red_canvas;
+    QLabel* _black_label, *_blue_label, *_red_label;
+    qint64 _last_time_60fps, _last_time_30fps, _last_time_10fps;
+    int _max_fps;
+    int _counter;
+};