Revision control
Copy as Markdown
// Copyright (C) 2024 Stan Morris.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QSGGeometry>
#include <QSGGeometryNode>
#include <QSGVertexColorMaterial>
#include <cmath>
#include <numbers>
#include "SpiralItem.h"
namespace {
std::array<int, 4> getParts(const QColor &color) {
return {color.red(), color.green(), color.blue(), color.alpha()};
}
using ColorPalette = std::array<QColor, 3>;
auto allocPalette = ColorPalette { QColor("aqua"), QColor("deepskyblue"), QColor("yellow") };
auto setVCPalette = ColorPalette { QColor("yellow"), QColor("orange"), QColor("white") };
}
SpiralItem::SpiralItem()
{
setFlag(QQuickItem::ItemHasContents);
setWidth(960);
setHeight(960);
connect(this, &SpiralItem::vertexCountChanged,
this, &QQuickItem::update);
connect(this, &SpiralItem::resizeByVertexCountChanged,
this, &SpiralItem::handleResizeByVertexCountChanged);
emit resizeByVertexCountChanged();
}
QSGNode *SpiralItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *) {
auto *n = static_cast<QSGGeometryNode *>(oldNode);
if (!n) {
n = new QSGGeometryNode();
setupGeometryNode(n);
}
if (auto *geometry = n->geometry()) {
if (m_vertexCount != geometry->vertexCount()) {
updateGeometry(geometry);
}
}
n->markDirty(QSGNode::DirtyGeometry);
return n;
}
void SpiralItem::updateGeometry(QSGGeometry *&geometry) {
if (m_resetVertices) {
m_resetVertices = false;
// must reallocate vertices if using setVertexCount to resize
if (m_resizeByVertexCount)
reallocateVertices(geometry, m_maxVertices);
}
const int newCount = qBound(0, m_vertexCount, m_maxVertices);
if (m_resizeByVertexCount) {
// change vertex count using new setVertexCount() function
geometry->setVertexCount(newCount);
} else {
// change vertex count using allocate()
reallocateVertices(geometry, newCount);
}
logStatistics();
}
void SpiralItem::setupGeometryNode(QSGGeometryNode *geometryNode)
{
// Set the geometry on the node
auto *geometry = createGeometry();
geometryNode->setGeometry(geometry);
geometryNode->setFlag(QSGNode::OwnsGeometry);
// Set a ColoredPoint2D material
geometryNode->setMaterial(new QSGVertexColorMaterial());
geometryNode->setFlag(QSGNode::OwnsMaterial);
}
QSGGeometry *SpiralItem::createGeometry()
{
auto *geometry = new QSGGeometry(QSGGeometry::defaultAttributes_ColoredPoint2D(),
m_maxVertices);
geometry->setDrawingMode(QSGGeometry::DrawLineStrip);
geometry->setLineWidth(3);
// populate the geometry
populateVertices(geometry, m_maxVertices);
populateColors(geometry, m_maxVertices);
return geometry;
}
void SpiralItem::populateVertices(QSGGeometry *geometry, const int count)
{
constexpr double pi = 3.14159265f;
constexpr int linesPerRing = 720;
constexpr float angleIncrement = 2 * pi / linesPerRing;
constexpr float lineSeparation = 6;
constexpr float radiusIncrement = lineSeparation / linesPerRing;
float radius = 1.5f;
float xOffset = width()/2;
float yOffset = height()/2;
float angle = float(2 * pi / 1000.f);;
// Iterate through all vertices
auto *pt = geometry->vertexDataAsColoredPoint2D();
for (int i = 0; i < count; ++i, ++pt) {
pt->x = radius * cos(angle) + xOffset;
pt->y = radius * sin(angle) + yOffset;
radius += radiusIncrement;
// Keep angle in 2*pi radians -- makes debugging easier
angle += angleIncrement;
if (angle > 2 * M_PI)
angle = (2 * M_PI) - angle;
}
}
void SpiralItem::populateColors(QSGGeometry *geometry, const int count)
{
constexpr int segmentLength = 20;
const auto& colors = m_resizeByVertexCount ? setVCPalette : allocPalette;
auto *pt = geometry->vertexDataAsColoredPoint2D();
for (int i = 0; i < count; ++i, ++pt) {
const bool isEndOfSpiral = i <= 20*segmentLength
|| i > (m_maxVertices - segmentLength);
auto index = isEndOfSpiral ? 2 :
((i/segmentLength)%2 == 0) ? 1
: 0;
const auto [r, g, b, a] = getParts(colors[index]);
pt->r = r;
pt->g = g;
pt->b = b;
pt->a = a;
}
}
void SpiralItem::reallocateVertices(QSGGeometry *geometry, const int count) {
geometry->allocate(count);
populateVertices(geometry, count);
populateColors(geometry, count);
}
void SpiralItem::logStatistics()
{
if (!m_animating)
return;
if (m_vertexCount > m_maxCount)
m_maxCount = m_vertexCount;
if (m_vertexCount < m_minCount)
m_minCount = m_vertexCount;
if (m_statisticsTimer.elapsed() >= 1000) {
qDebug() << m_mode
<< "\tfps:" << m_fps
<< "\tvertices:" << m_minCount << "-" << m_maxCount;
m_statisticsTimer.restart();
m_maxCount = -1;
m_minCount = m_maxVertices;
}
}
int SpiralItem::vertexCount() const
{
return m_vertexCount;
}
void SpiralItem::setVertexCount(int newVertexCount)
{
if (m_vertexCount == newVertexCount)
return;
m_vertexCount = newVertexCount;
emit vertexCountChanged();
}
int SpiralItem::maxVertices() const
{
return m_maxVertices;
}
int SpiralItem::fps() const
{
return m_fps;
}
void SpiralItem::setFps(int newFps)
{
if (m_fps == newFps)
return;
m_fps = newFps;
emit fpsChanged();
}
void SpiralItem::toggleMode()
{
if (!m_animating) {
// Set up to alternate between techniques for resizing geometry
m_statisticsTimer.start();
m_animating = true;
}
// Toggle between using setVertexCount() and allocate() to resize geometry
setResizeByVertexCount(!m_resizeByVertexCount);
m_resetVertices = true;
}
void SpiralItem::handleResizeByVertexCountChanged()
{
setMode(m_resizeByVertexCount ? "setVertexCount()" : "allocate()");
}
QString SpiralItem::mode() const
{
return m_mode;
}
void SpiralItem::setMode(const QString &newMode)
{
if (m_mode == newMode)
return;
m_mode = newMode;
emit modeChanged();
}
bool SpiralItem::resizeByVertexCount() const
{
return m_resizeByVertexCount;
}
void SpiralItem::setResizeByVertexCount(bool newResizeByVertexCount)
{
if (m_resizeByVertexCount == newResizeByVertexCount)
return;
m_resizeByVertexCount = newResizeByVertexCount;
emit resizeByVertexCountChanged();
}