3party/easy_profiler
0
0
Fork 0
mirror of https://github.com/yse/easy_profiler.git synced 2024-12-25 23:40:51 +08:00
Code Issues Projects Releases Wiki Activity
easy_profiler/profiler_gui/fps_widget.cpp
sk-landry bfeb4ee6f8 Port to Qt6
2024-05-13 04:09:30 -04:00

369 lines
13 KiB
C++
Raw Permalink Blame History

/************************************************************************
* file name : fps_widget.cpp
* ----------------- :
* creation time : 2017/04/02
* author : Victor Zarubkin
* email : v.s.zarubkin@gmail.com
* ----------------- :
* description : This file contains implementation of FpsWidget widget.
* ----------------- :
* change log : * 2017/04/02 Victor Zarubkin: Initial commit.
* :
* : *
* ----------------- :
* license : Lightweight profiler library for c++
* : Copyright(C) 2016-2019 Sergey Yagovtsev, Victor Zarubkin
* :
* : Licensed under either of
* : * MIT license (LICENSE.MIT or http://opensource.org/licenses/MIT)
* : * Apache License, Version 2.0, (LICENSE.APACHE or http://www.apache.org/licenses/LICENSE-2.0)
* : at your option.
* :
* : The MIT License
* :
* : Permission is hereby granted, free of charge, to any person obtaining a copy
* : of this software and associated documentation files (the "Software"), to deal
* : in the Software without restriction, including without limitation the rights
* : to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* : of the Software, and to permit persons to whom the Software is furnished
* : to do so, subject to the following conditions:
* :
* : The above copyright notice and this permission notice shall be included in all
* : copies or substantial portions of the Software.
* :
* : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* : INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* : PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* : LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* : TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* : USE OR OTHER DEALINGS IN THE SOFTWARE.
* :
* : The Apache License, Version 2.0 (the "License")
* :
* : You may not use this file except in compliance with the License.
* : You may obtain a copy of the License at
* :
* : http://www.apache.org/licenses/LICENSE-2.0
* :
* : Unless required by applicable law or agreed to in writing, software
* : distributed under the License is distributed on an "AS IS" BASIS,
* : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* : See the License for the specific language governing permissions and
* : limitations under the License.
************************************************************************/
#include <QGraphicsScene>
#include <QResizeEvent>
#include <QContextMenuEvent>
#include <QMenu>
#include <QAction>
#include "fps_widget.h"
#include "globals.h"
const int INTERVAL_WIDTH = 20;
//////////////////////////////////////////////////////////////////////////
FpsGraphicsItem::FpsGraphicsItem() : Parent(nullptr)
{
}
FpsGraphicsItem::~FpsGraphicsItem()
{
}
//////////////////////////////////////////////////////////////////////////
QRectF FpsGraphicsItem::boundingRect() const
{
return m_boundingRect;
}
void FpsGraphicsItem::setBoundingRect(const QRectF& _boundingRect)
{
m_boundingRect = _boundingRect;
}
void FpsGraphicsItem::setBoundingRect(qreal x, qreal y, qreal w, qreal h)
{
m_boundingRect.setRect(x, y, w, h);
}
//////////////////////////////////////////////////////////////////////////
void FpsGraphicsItem::paint(QPainter* _painter, const QStyleOptionGraphicsItem*, QWidget*)
{
if (m_frames.empty())
return;
const auto fontMetrics = QFontMetrics(scene()->font());
const int fontHeight = fontMetrics.height() + 1;
const qreal h = m_boundingRect.height() - (fontHeight << 1) - 2;
if (h < 0)
return;
const qreal halfWidth = m_boundingRect.width() * 0.5 - INTERVAL_WIDTH;
const int halfMax = static_cast<int>(0.5 + halfWidth / INTERVAL_WIDTH);
const int half = static_cast<int>(m_frames.size() / 2);
const qreal top = fontHeight, bottom = h + 2 + fontHeight;
qreal y;
_painter->save();
_painter->drawLine(QPointF(0, top), QPointF(m_boundingRect.width(), top));
_painter->drawLine(QPointF(0, bottom), QPointF(m_boundingRect.width(), bottom));
const auto maxLines = static_cast<int>(h / fontHeight);
_painter->setPen(Qt::lightGray);
y = m_boundingRect.height() * 0.5;
if (maxLines != 2)
_painter->drawLine(QPointF(0, y), QPointF(m_boundingRect.width(), y));
y -= h * 0.25;
if (maxLines >= 2)
_painter->drawLine(QPointF(0, y), QPointF(m_boundingRect.width(), y));
y += h * 0.5;
if (maxLines >= 2)
_painter->drawLine(QPointF(0, y), QPointF(m_boundingRect.width(), y));
m_points1.reserve(m_frames.size());
m_points2.reserve(m_frames.size());
int n = 0;
qreal x = m_boundingRect.width() * 0.5 + std::min(halfMax, half) * INTERVAL_WIDTH, localMax = 0, localMin = 1e30;
const qreal xCurrent = x;
for (int i = static_cast<int>(m_frames.size()) - 1; i > -1 && x >= 0; --i, x -= INTERVAL_WIDTH, ++n)
{
const auto& val = m_frames[i];
if (val.first > localMax)
localMax = val.first;
if (val.first < localMin)
localMin = val.first;
m_points1.emplace_back(x, static_cast<qreal>(val.first) + 1e-3);
if (val.second > localMax)
localMax = val.second;
if (val.second < localMin)
localMin = val.second;
m_points2.emplace_back(x, static_cast<qreal>(val.second) + 1e-3);
_painter->drawLine(QPointF(x, top + 1), QPointF(x, bottom - 1));
}
const auto delta = std::max(localMax - localMin, 1e-3);
_painter->setPen(Qt::black);
qreal frameTime = std::max(localMax, 1.);
auto fps = static_cast<quint64>(1e6 / frameTime);
_painter->drawText(5, 0, m_boundingRect.width() - 10, fontHeight, Qt::AlignVCenter | Qt::AlignLeft, QString("Slowest %1 (%2 FPS)")
.arg(::profiler_gui::timeStringReal(EASY_GLOBALS.time_units, localMax, 1)).arg(fps));
frameTime = std::max(m_frames.back().first, 1U);
fps = static_cast<quint64>(1e6 / frameTime);
_painter->drawText(5, 0, xCurrent - 5, fontHeight, Qt::AlignVCenter | Qt::AlignRight, QString("Max current %1 (%2 FPS)")
.arg(::profiler_gui::timeStringReal(EASY_GLOBALS.time_units, m_frames.back().first, 1)).arg(fps));
frameTime = std::max(m_frames.back().second, 1U);
fps = static_cast<quint64>(1e6 / frameTime);
_painter->drawText(5, bottom, xCurrent - 5, fontHeight, Qt::AlignVCenter | Qt::AlignRight, QString("Avg current %1 (%2 FPS)")
.arg(::profiler_gui::timeStringReal(EASY_GLOBALS.time_units, m_frames.back().second, 1)).arg(fps));
frameTime = std::max(localMin, 1.);
fps = static_cast<quint64>(1e6 / frameTime);
_painter->drawText(5, bottom, m_boundingRect.width() - 10, fontHeight, Qt::AlignVCenter | Qt::AlignLeft, QString("Fastest %1 (%2 FPS)")
.arg(::profiler_gui::timeStringReal(EASY_GLOBALS.time_units, localMin, 1)).arg(fps));
if (localMin < EASY_GLOBALS.frame_time && EASY_GLOBALS.frame_time < localMax)
{
y = fontHeight + 2 + h * (1. - (EASY_GLOBALS.frame_time - localMin) / delta);
_painter->setPen(Qt::DashLine);
_painter->drawLine(QPointF(0, y), QPointF(m_boundingRect.width(), y));
}
for (int i = 0; i < n; ++i)
{
auto& point1 = m_points1[i];
point1.setY(fontHeight + 2 + h * (1. - (point1.y() - localMin) / delta));
auto& point2 = m_points2[i];
point2.setY(fontHeight + 2 + h * (1. - (point2.y() - localMin) / delta));
}
_painter->setRenderHint(QPainter::Antialiasing, true);
QPen pen(QColor::fromRgba(0x80ff0000));
pen.setWidth(EASY_GLOBALS.fps_widget_line_width);
_painter->setPen(pen);
if (n > 1)
{
_painter->drawPolyline(m_points1.data(), n);
pen.setColor(QColor::fromRgba(0x800000ff));
_painter->setPen(pen);
_painter->drawPolyline(m_points2.data(), n);
}
else
{
_painter->drawPoint(m_points1.back());
pen.setColor(QColor::fromRgba(0x800000ff));
_painter->setPen(pen);
_painter->drawPoint(m_points2.back());
}
const auto txtTop = ::profiler_gui::timeStringReal(EASY_GLOBALS.time_units, localMin + delta * 0.75, 1);
const auto txtMid = ::profiler_gui::timeStringReal(EASY_GLOBALS.time_units, localMin + delta * 0.5, 1);
const auto txtBtm = ::profiler_gui::timeStringReal(EASY_GLOBALS.time_units, localMin + delta * 0.25, 1);
_painter->setPen(Qt::NoPen);
_painter->setBrush(Qt::white);
_painter->drawRect(0, top + 1, std::max({fontMetrics.boundingRect(txtTop).width(),
fontMetrics.boundingRect(txtMid).width(),
fontMetrics.boundingRect(txtBtm).width()}) + 8, bottom - top - 1);
_painter->setPen(Qt::black);
_painter->setBrush(Qt::NoBrush);
y = m_boundingRect.height() * 0.5;
if (maxLines != 2)
_painter->drawText(5, y - (fontHeight >> 1), m_boundingRect.width(), fontHeight, Qt::AlignVCenter | Qt::AlignLeft, txtMid);
y -= h * 0.25;
if (maxLines >= 2)
_painter->drawText(5, y - (fontHeight >> 1), m_boundingRect.width(), fontHeight, Qt::AlignVCenter | Qt::AlignLeft, txtTop);
y += h * 0.5;
if (maxLines >= 2)
_painter->drawText(5, y - (fontHeight >> 1), m_boundingRect.width(), fontHeight, Qt::AlignVCenter | Qt::AlignLeft, txtBtm);
_painter->restore();
m_points1.clear();
m_points2.clear();
}
//////////////////////////////////////////////////////////////////////////
void FpsGraphicsItem::clear()
{
m_frames.clear();
}
void FpsGraphicsItem::addPoint(uint32_t _maxFrameTime, uint32_t _avgFrameTime)
{
m_frames.emplace_back(_maxFrameTime, _avgFrameTime);
if (static_cast<int>(m_frames.size()) > EASY_GLOBALS.max_fps_history)
m_frames.pop_front();
}
//////////////////////////////////////////////////////////////////////////
FpsWidget::FpsWidget(QWidget* _parent) : Parent(_parent), m_fpsItem(nullptr)
{
setCacheMode(QGraphicsView::CacheNone);
//setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
setOptimizationFlag(QGraphicsView::DontSavePainterState, true);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setContentsMargins(0, 0, 0, 0);
setScene(new QGraphicsScene(this));
scene()->setSceneRect(0, 0, 50, 50);
m_fpsItem = new FpsGraphicsItem();
m_fpsItem->setPos(0, 0);
m_fpsItem->setBoundingRect(0, 0, 50, 50);
scene()->addItem(m_fpsItem);
centerOn(0, 0);
// Dirty hack for QDockWidget stupid initial size policy :(
setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Preferred);
setFixedHeight(10); // Set very small height to enable appropriate minimum height on the application startup
QTimer::singleShot(100, [this]
{
// Now set appropriate minimum height
setMinimumHeight((QFontMetrics(scene()->font()).height() + px(3)) * 3);
setMaximumHeight(minimumHeight() * 20);
});
}
FpsWidget::~FpsWidget()
{
}
void FpsWidget::clear()
{
m_fpsItem->clear();
scene()->update();
}
void FpsWidget::addPoint(uint32_t _maxFrameTime, uint32_t _avgFrameTime)
{
m_fpsItem->addPoint(_maxFrameTime, _avgFrameTime);
scene()->update();
}
QSize FpsWidget::sizeHint() const
{
return QSize(Parent::sizeHint().width(), minimumHeight());
}
QSize FpsWidget::minimumSizeHint() const
{
return QSize(Parent::minimumSizeHint().width(), minimumHeight());
}
void FpsWidget::resizeEvent(QResizeEvent* _event)
{
Parent::resizeEvent(_event);
auto size = _event->size();
m_fpsItem->setBoundingRect(0, 0, size.width(), size.height());
scene()->setSceneRect(m_fpsItem->boundingRect());
scene()->update();
}
void FpsWidget::hideEvent(QHideEvent* _event)
{
Parent::hideEvent(_event);
EASY_GLOBALS.fps_enabled = isVisible();
clear();
}
void FpsWidget::showEvent(QShowEvent* _event)
{
Parent::showEvent(_event);
EASY_GLOBALS.fps_enabled = isVisible();
clear();
}
void FpsWidget::contextMenuEvent(QContextMenuEvent* _event)
{
QMenu menu;
QAction* action = nullptr;
action = menu.addAction(QIcon(imagePath("delete")), "Clear");
connect(action, &QAction::triggered, [this](bool){ clear(); });
action = menu.addAction("Close");
connect(action, &QAction::triggered, [this](bool){ parentWidget()->hide(); });
menu.exec(QCursor::pos());
_event->accept();
}
//////////////////////////////////////////////////////////////////////////
Reference in New Issue View Git Blame Copy Permalink