lenn/tactileipc3d
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

first commit

Browse Source
This commit is contained in:
lenn
2025-12-18 09:19:39 +08:00
parent 1bc7adf399
commit d4975da9a5
24 changed files with 2506 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
src/backend.cpp Normal file
View File

@@ -0,0 +1,64 @@
//
// Created by Lenn on 2025/12/16.
//
#include "backend.h"
static QString normalizeRenderMode_(const QString& mode) {
if (mode.compare(QStringLiteral("realistic"), Qt::CaseInsensitive) == 0)
return QStringLiteral("realistic");
return QStringLiteral("dataViz");
}
static QString normalizeLabelMode_(const QString& mode) {
if (mode.compare(QStringLiteral("hover"), Qt::CaseInsensitive) == 0)
return QStringLiteral("hover");
if (mode.compare(QStringLiteral("always"), Qt::CaseInsensitive) == 0)
return QStringLiteral("always");
return QStringLiteral("off");
}
Backend::Backend(QObject *parent)
: QObject(parent) {
}
void Backend::setMinValue(int v) {
if (m_min == v)
return;
m_min = v;
emit minValueChanged();
emit rangeChanged(m_min, m_max);
}
void Backend::setMaxValue(int v) {
if (m_max == v)
return;
m_max = v;
emit maxValueChanged();
emit rangeChanged(m_min, m_max);
}
void Backend::setRenderMode(const QString &mode) {
const QString norm = normalizeRenderMode_(mode);
if (m_renderMode == norm)
return;
m_renderMode = norm;
emit renderModeChanged();
emit renderModeValueChanged(m_renderMode);
}
void Backend::setShowLegend(bool show) {
if (m_showLegend == show)
return;
m_showLegend = show;
emit showLegendChanged();
}
void Backend::setLabelMode(const QString &mode) {
const QString norm = normalizeLabelMode_(mode);
if (m_labelMode == norm)
return;
m_labelMode = norm;
emit labelModeChanged();
emit labelModeValueChanged(m_labelMode);
}

54
src/backend.h Normal file
View File

@@ -0,0 +1,54 @@
//
// Created by Lenn on 2025/12/16.
//
#ifndef TACTILEIPC3D_BACKEND_H
#define TACTILEIPC3D_BACKEND_H
#include <qobject.h>
#include <QString>
class Backend : public QObject {
Q_OBJECT
Q_PROPERTY(int minValue READ minValue WRITE setMinValue NOTIFY minValueChanged)
Q_PROPERTY(int maxValue READ maxValue WRITE setMaxValue NOTIFY maxValueChanged)
Q_PROPERTY(QString renderMode READ renderMode WRITE setRenderMode NOTIFY renderModeChanged)
Q_PROPERTY(bool showLegend READ showLegend WRITE setShowLegend NOTIFY showLegendChanged)
Q_PROPERTY(QString labelMode READ labelMode WRITE setLabelMode NOTIFY labelModeChanged)
public:
explicit Backend(QObject* parent = nullptr);
int minValue() const { return m_min; }
int maxValue() const { return m_max; }
QString renderMode() const { return m_renderMode; }
bool showLegend() const { return m_showLegend; }
QString labelMode() const { return m_labelMode; }
public slots:
void setMinValue(int v);
void setMaxValue(int v);
void setRenderMode(const QString& mode);
void setShowLegend(bool show);
void setLabelMode(const QString& mode);
signals:
void minValueChanged();
void maxValueChanged();
void renderModeChanged();
void showLegendChanged();
void labelModeChanged();
void rangeChanged(int minV, int maxV);
void renderModeValueChanged(const QString& mode);
void labelModeValueChanged(const QString& mode);
private:
int m_min = 100;
int m_max = 2000;
QString m_renderMode = QStringLiteral("dataViz");
bool m_showLegend = true;
QString m_labelMode = QStringLiteral("off");
};
#endif //TACTILEIPC3D_BACKEND_H

851
src/glwidget.cpp Normal file
View File

@@ -0,0 +1,851 @@
//
// Created by Lenn on 2025/12/16.
//
#include "glwidget.h"
#include <QOpenGLShaderProgram>
#include <QByteArray>
#include <QtMath>
#include <QFile>
#include <QDebug>
#include <qevent.h>
#include <QVector3D>
#include <QVector2D>
#include <QVector4D>
#include <QImage>
#include <QPainter>
#include <QFontMetrics>
#include <limits>
// 读取文本文件内容（这里主要用来从 Qt Resource `:/shaders/...` 读取 shader 源码）
static QByteArray readFile(const QString& path) {
QFile f(path);
if (!f.open(QIODevice::ReadOnly)) return {};
return f.readAll();
}
// 简单的 4x4 单位矩阵（目前只用于保留的 float[16] 版本）
static void matIdentity(float m[16]) {
for (int i = 0; i < 16; i++) {
m[i] = 0;
}
m[0] = m[5] = m[10] = m[15] = 1;
}
GLWidget::GLWidget(QWidget *parent)
: QOpenGLWidget(parent) {
setMinimumSize(640, 480);
}
GLWidget::~GLWidget() {
makeCurrent();
delete m_bgProg;
delete m_panelProg;
delete m_dotsProg;
if (m_panelIbo)
glDeleteBuffers(1, &m_panelIbo);
if (m_panelVbo)
glDeleteBuffers(1, &m_panelVbo);
if (m_panelVao)
glDeleteVertexArrays(1, &m_panelVao);
if (m_dotsVao)
glDeleteVertexArrays(1, &m_dotsVao);
if (m_dotsVbo)
glDeleteBuffers(1, &m_dotsVbo);
if (m_instanceVbo)
glDeleteBuffers(1, &m_instanceVbo);
if (m_bgVbo)
glDeleteBuffers(1, &m_bgVbo);
if (m_bgVao)
glDeleteVertexArrays(1, &m_bgVao);
if (m_dotTex)
glDeleteTextures(1, &m_dotTex);
doneCurrent();
}
void GLWidget::setPanelSize(float w, float h, float d) {
m_panelW = w;
m_panelH = h;
m_panelD = d;
m_panelGeometryDirty = true;
update();
}
void GLWidget::setPanelThickness(float h) {
if (qFuzzyCompare(m_panelH, h))
return;
m_panelH = h;
m_panelGeometryDirty = true;
update();
}
void GLWidget::setSpec(int rows, int cols, float pitch, float dotRaius) {
m_rows = qMax(0, rows);
m_cols = qMax(0, cols);
m_pitch = qMax(0.0f, pitch);
m_dotRadius = qMax(0.0f, dotRaius);
// 自动根据点阵尺寸调整 panel 的尺寸（保证圆点不会越过顶面边界）。
// 约定：点中心覆盖的范围是 (cols-1)*pitch / (rows-1)*pitch，面板需要额外留出 dotRadius 的边缘空间。
const float gridW = float(qMax(0, m_cols - 1)) * m_pitch;
const float gridD = float(qMax(0, m_rows - 1)) * m_pitch;
m_panelW = gridW + 2.0f * m_dotRadius;
m_panelD = gridD + 2.0f * m_dotRadius;
m_panelGeometryDirty = true;
m_dotsGeometryDirty = true;
QMutexLocker lk(&m_dataMutex);
m_latestValues.resize(dotCount());
for (int i = 0; i < m_latestValues.size(); ++i) {
m_latestValues[i] = m_min;
}
m_valuesDirty = true;
m_hasData = false;
update();
}
void GLWidget::submitValues(const QVector<float> &values) {
if (values.size() != dotCount()) return;
{
QMutexLocker lk(&m_dataMutex);
m_latestValues = values;
m_valuesDirty = true;
m_hasData = true;
}
update();
}
void GLWidget::setRange(int minV, int maxV) {
m_min = minV;
m_max = maxV;
update();
}
void GLWidget::setYaw(float yawDeg) {
if (qFuzzyCompare(m_camYawDeg, yawDeg))
return;
m_camYawDeg = yawDeg;
emit yawChanged();
update();
}
void GLWidget::setRenderModeString(const QString &mode) {
RenderMode next = DataViz;
if (mode.compare(QStringLiteral("realistic"), Qt::CaseInsensitive) == 0) {
next = Realistic;
} else if (mode.compare(QStringLiteral("dataViz"), Qt::CaseInsensitive) == 0) {
next = DataViz;
}
if (m_renderMode == next)
return;
m_renderMode = next;
update();
}
void GLWidget::setLabelModeString(const QString &mode) {
LabelMode next = LabelsOff;
if (mode.compare(QStringLiteral("hover"), Qt::CaseInsensitive) == 0) {
next = LabelsHover;
} else if (mode.compare(QStringLiteral("always"), Qt::CaseInsensitive) == 0) {
next = LabelsAlways;
} else if (mode.compare(QStringLiteral("off"), Qt::CaseInsensitive) == 0) {
next = LabelsOff;
}
if (m_labelMode == next)
return;
m_labelMode = next;
if (m_labelMode == LabelsOff)
m_hoveredIndex = -1;
update();
}
void GLWidget::initializeGL() {
initializeOpenGLFunctions();
// 基础状态：开启深度测试，否则 3D 物体的遮挡关系会不正确
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
initPrograms_();
initDotTexture_();
initBackgroundGeometry_();
initPanelGeometry_();
initDotGeometry_();
m_panelGeometryDirty = false;
m_dotsGeometryDirty = false;
matIdentity(m_modelPanel);
matIdentity(m_view);
matIdentity(m_proj);
}
void GLWidget::resizeGL(int w, int h) {
glViewport(0, 0, w, h);
}
void GLWidget::paintGL() {
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// 如果点阵规格/面板尺寸发生变化，需要在有 GL 上下文时重建几何体 buffer。
if (m_panelGeometryDirty) {
initPanelGeometry_();
m_panelGeometryDirty = false;
}
if (m_dotsGeometryDirty) {
initDotGeometry_();
m_dotsGeometryDirty = false;
m_valuesDirty = true; // instanceVBO 重新分配后需要重新上传数据
}
// --- 背景：屏幕空间网格（不随相机旋转）---
if (m_bgProg && m_bgVao) {
const float dpr = devicePixelRatioF();
const QVector2D viewport(float(width()) * dpr, float(height()) * dpr);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
m_bgProg->bind();
m_bgProg->setUniformValue("uViewport", viewport);
m_bgProg->setUniformValue("uMinorStep", 24.0f * dpr);
m_bgProg->setUniformValue("uMajorStep", 120.0f * dpr);
glBindVertexArray(m_bgVao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
m_bgProg->release();
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
}
// 1) 更新相机/投影矩阵（MVP），决定如何把 3D 世界投影到屏幕
updateMatrices_();
// 2) 如果外部提交了新数据，就把 CPU 生成的 instance 数据更新到 GPU
updateInstanceBufferIfNeeded_();
if (m_panelProg) {
m_panelProg->bind();
// uniforms：每次 draw 前设置的一组“常量参数”（对当前 draw call 的所有顶点/片元都一致）
// uMVP: Model-View-Projection 矩阵（把顶点从世界坐标 -> 裁剪空间；gl_Position 必须输出裁剪空间坐标）
m_panelProg->setUniformValue("uMVP", m_mvp);
m_panelProg->setUniformValue("uCameraPos", m_cameraPos);
m_panelProg->setUniformValue("uPanelW", m_panelW);
m_panelProg->setUniformValue("uPanelH", m_panelH);
m_panelProg->setUniformValue("uPanelD", m_panelD);
m_panelProg->setUniformValue("uRows", m_rows);
m_panelProg->setUniformValue("uCols", m_cols);
m_panelProg->setUniformValue("uPitch", m_pitch);
m_panelProg->setUniformValue("uDotRadius", m_dotRadius);
m_panelProg->setUniformValue("uRenderMode", int(m_renderMode));
glBindVertexArray(m_panelVao);
glDrawElements(GL_TRIANGLES, m_panelIndexCount, GL_UNSIGNED_INT, nullptr);
glBindVertexArray(0);
m_panelProg->release();
}
if (m_dotsProg) {
m_dotsProg->bind();
// uniforms：每次 draw 前设置的一组“常量参数”（对当前 draw call 的所有 instance 都一致）
// uMVP: 同上；用于把每个 dot 的世界坐标变换到屏幕
m_dotsProg->setUniformValue("uMVP", m_mvp);
m_dotsProg->setUniformValue("uRenderMode", int(m_renderMode));
// uDotRadius: dot 的半径（世界坐标单位）
m_dotsProg->setUniformValue("uDotRadius", m_dotRadius);
// uBaseY: dot 的高度（放在 panel 顶面上方一点点，避免 z-fighting/闪烁）
m_dotsProg->setUniformValue("uBaseY", (m_panelH * 0.5f) + 0.001f);
// uMinV/uMaxV: 传感值范围，用于 fragment shader 把 value 映射成颜色
m_dotsProg->setUniformValue("uMinV", float(m_min));
m_dotsProg->setUniformValue("uMaxV", float(m_max));
const int hasData = (m_hasData.load() || m_dotTex == 0) ? 1 : 0;
m_dotsProg->setUniformValue("uHasData", hasData);
m_dotsProg->setUniformValue("uCameraPos", m_cameraPos);
m_dotsProg->setUniformValue("uDotTex", 0);
if (m_dotTex) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, m_dotTex);
}
glBindVertexArray(m_dotsVao);
glDrawArraysInstanced(GL_TRIANGLES, 0, 6, m_instanceCount);
glBindVertexArray(0);
if (m_dotTex) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
}
m_dotsProg->release();
}
if (m_labelMode != LabelsOff && dotCount() > 0) {
QVector<float> valuesCopy;
{
QMutexLocker lk(&m_dataMutex);
valuesCopy = m_latestValues;
}
auto projectToScreen = [&](const QVector3D& world, QPointF& out) -> bool {
const QVector4D clip = m_mvp * QVector4D(world, 1.0f);
if (clip.w() <= 1e-6f)
return false;
const QVector3D ndc = clip.toVector3D() / clip.w();
if (ndc.z() < -1.2f || ndc.z() > 1.2f)
return false;
out.setX((ndc.x() * 0.5f + 0.5f) * float(width()));
out.setY((1.0f - (ndc.y() * 0.5f + 0.5f)) * float(height()));
return true;
};
const float baseY = (m_panelH * 0.5f) + 0.001f;
const float w = (m_cols - 1) * m_pitch;
const float h = (m_rows - 1) * m_pitch;
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setRenderHint(QPainter::TextAntialiasing, true);
QFont font = painter.font();
font.setPixelSize(11);
painter.setFont(font);
const QFontMetrics fm(font);
auto drawLabel = [&](const QPointF& anchor, const QPointF& offset, const QString& text) {
QRectF box = fm.boundingRect(text);
box.adjust(-6.0, -3.0, 6.0, 3.0);
box.moveCenter(anchor + offset);
const float margin = 4.0f;
if (box.left() < margin) box.moveLeft(margin);
if (box.top() < margin) box.moveTop(margin);
if (box.right() > width() - margin) box.moveRight(width() - margin);
if (box.bottom() > height() - margin) box.moveBottom(height() - margin);
painter.setPen(Qt::NoPen);
painter.setBrush(QColor(0, 0, 0, 150));
painter.drawRoundedRect(box, 4.0, 4.0);
painter.setPen(QColor(255, 255, 255, 235));
painter.drawText(box, Qt::AlignCenter, text);
};
auto dotWorldCenter = [&](int i) -> QVector3D {
const int rr = (m_cols > 0) ? (i / m_cols) : 0;
const int cc = (m_cols > 0) ? (i % m_cols) : 0;
const float x = (cc * m_pitch) - w * 0.5f;
const float z = (rr * m_pitch) - h * 0.5f;
return QVector3D(x, baseY, z);
};
auto dotRadiusPx = [&](const QVector3D& worldCenter, const QPointF& centerPx) -> float {
QPointF edge;
if (!projectToScreen(worldCenter + QVector3D(m_dotRadius, 0.0f, 0.0f), edge))
return 0.0f;
const float dx = float(edge.x() - centerPx.x());
const float dy = float(edge.y() - centerPx.y());
return std::sqrt(dx * dx + dy * dy);
};
if (m_labelMode == LabelsAlways && valuesCopy.size() == dotCount()) {
painter.setPen(QColor(255, 255, 255, 220));
for (int i = 0; i < dotCount(); ++i) {
QPointF centerPx;
const QVector3D world = dotWorldCenter(i);
if (!projectToScreen(world, centerPx))
continue;
const float rPx = dotRadiusPx(world, centerPx);
if (rPx < 12.0f)
continue;
const QString text = QString::number(int(valuesCopy[i] + 0.5f));
drawLabel(centerPx, QPointF(0.0, 0.0), text);
}
}
if (m_hoveredIndex >= 0 && m_hoveredIndex < dotCount() && valuesCopy.size() == dotCount()) {
QPointF centerPx;
const QVector3D world = dotWorldCenter(m_hoveredIndex);
if (projectToScreen(world, centerPx)) {
const float rPx = dotRadiusPx(world, centerPx);
painter.setBrush(Qt::NoBrush);
painter.setPen(QPen(QColor(255, 255, 255, 210), 1.5));
painter.drawEllipse(centerPx, rPx * 1.08f, rPx * 1.08f);
if (m_labelMode == LabelsHover) {
const QString text = QString::number(int(valuesCopy[m_hoveredIndex] + 0.5f));
drawLabel(centerPx, QPointF(0.0, -rPx - 12.0f), text);
}
}
}
}
}
void GLWidget::mousePressEvent(QMouseEvent *event) {
m_lastPos = event->pos();
if (event->button() == Qt::RightButton) {
m_rightDown = true;
event->accept();
return;
}
QOpenGLWidget::mousePressEvent(event);
}
void GLWidget::mouseMoveEvent(QMouseEvent *event) {
const QPoint delta = event->pos() - m_lastPos;
m_lastPos = event->pos();
if (m_rightDown) {
m_camYawDeg += delta.x() * 0.3f;
m_camPitchDeg = qBound(-89.0f, m_camPitchDeg + delta.y() * 0.3f, 89.0f);
emit yawChanged();
update();
event->accept();
return;
}
if (m_labelMode != LabelsOff && dotCount() > 0) {
auto projectToScreen = [&](const QVector3D& world, QPointF& out) -> bool {
const QVector4D clip = m_mvp * QVector4D(world, 1.0f);
if (clip.w() <= 1e-6f)
return false;
const QVector3D ndc = clip.toVector3D() / clip.w();
if (ndc.z() < -1.2f || ndc.z() > 1.2f)
return false;
out.setX((ndc.x() * 0.5f + 0.5f) * float(width()));
out.setY((1.0f - (ndc.y() * 0.5f + 0.5f)) * float(height()));
return true;
};
const QPoint mousePos = event->pos();
const float baseY = (m_panelH * 0.5f) + 0.001f;
const float w = (m_cols - 1) * m_pitch;
const float h = (m_rows - 1) * m_pitch;
int best = -1;
float bestDist2 = std::numeric_limits<float>::infinity();
for (int i = 0; i < dotCount(); ++i) {
const int rr = (m_cols > 0) ? (i / m_cols) : 0;
const int cc = (m_cols > 0) ? (i % m_cols) : 0;
const float x = (cc * m_pitch) - w * 0.5f;
const float z = (rr * m_pitch) - h * 0.5f;
QPointF center;
const QVector3D worldCenter(x, baseY, z);
if (!projectToScreen(worldCenter, center))
continue;
QPointF edge;
if (!projectToScreen(worldCenter + QVector3D(m_dotRadius, 0.0f, 0.0f), edge))
continue;
const float radDx = float(edge.x() - center.x());
const float radDy = float(edge.y() - center.y());
const float radPx = std::sqrt(radDx * radDx + radDy * radDy);
const float threshold = radPx + 6.0f;
const float dx = float(mousePos.x()) - float(center.x());
const float dy = float(mousePos.y()) - float(center.y());
const float dist2 = dx * dx + dy * dy;
if (dist2 <= threshold * threshold && dist2 < bestDist2) {
best = i;
bestDist2 = dist2;
}
}
if (best != m_hoveredIndex) {
m_hoveredIndex = best;
update();
}
}
QOpenGLWidget::mouseMoveEvent(event);
}
void GLWidget::mouseReleaseEvent(QMouseEvent *event) {
if (event->button() == Qt::RightButton) {
m_rightDown = false;
event->accept();
return;
}
QOpenGLWidget::mouseReleaseEvent(event);
}
void GLWidget::wheelEvent(QWheelEvent *event) {
const float steps = event->angleDelta().y() / 120.0f;
const float factor = std::pow(0.9f, steps);
m_zoom_ = qBound(0.2f, m_zoom_ * factor, 45.0f);
update();
event->accept();
}
void GLWidget::initBackgroundGeometry_() {
if (m_bgVbo) {
glDeleteBuffers(1, &m_bgVbo);
m_bgVbo = 0;
}
if (m_bgVao) {
glDeleteVertexArrays(1, &m_bgVao);
m_bgVao = 0;
}
// 全屏 quad（两个三角形），坐标直接是裁剪空间 NDC [-1,1]
const float verts[] = {
-1.0f, -1.0f,
1.0f, -1.0f,
1.0f, 1.0f,
-1.0f, -1.0f,
1.0f, 1.0f,
-1.0f, 1.0f,
};
glGenVertexArrays(1, &m_bgVao);
glBindVertexArray(m_bgVao);
glGenBuffers(1, &m_bgVbo);
glBindBuffer(GL_ARRAY_BUFFER, m_bgVbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0);
glBindVertexArray(0);
}
void GLWidget::initPanelGeometry_() {
// panel：目前只画“顶面矩形”，y 固定在 +panelH/2
if (m_panelIbo) {
glDeleteBuffers(1, &m_panelIbo);
m_panelIbo = 0;
}
if (m_panelVbo) {
glDeleteBuffers(1, &m_panelVbo);
m_panelVbo = 0;
}
if (m_panelVao) {
glDeleteVertexArrays(1, &m_panelVao);
m_panelVao = 0;
}
const float y = m_panelH * 0.5f;
const float hw = m_panelW * 0.5;
const float hd = m_panelD * 0.5f;
struct V {
float x, y, z;
float nx, ny, nz;
};
V verts[24] = {
// +Y 顶面 (normal 0, +1, 0)
{-hw, +y, -hd, 0, +1, 0}, // 0
{+hw, +y, -hd, 0, +1, 0}, // 1
{+hw, +y, +hd, 0, +1, 0}, // 2
{-hw, +y, +hd, 0, +1, 0}, // 3
// +Z 前面 (normal 0, 0, +1)
{-hw, +y, +hd, 0, 0, +1}, // 4
{+hw, +y, +hd, 0, 0, +1}, // 5
{+hw, -y, +hd, 0, 0, +1}, // 6
{-hw, -y, +hd, 0, 0, +1}, // 7
// -Y 底面 (normal 0, -1, 0)
{-hw, -y, +hd, 0, -1, 0}, // 8
{+hw, -y, +hd, 0, -1, 0}, // 9
{+hw, -y, -hd, 0, -1, 0}, // 10
{-hw, -y, -hd, 0, -1, 0}, // 11
// -Z 后面 (normal 0, 0, -1)
{+hw, +y, -hd, 0, 0, -1}, // 12
{-hw, +y, -hd, 0, 0, -1}, // 13
{-hw, -y, -hd, 0, 0, -1}, // 14
{+hw, -y, -hd, 0, 0, -1}, // 15
// -X 左面 (normal -1, 0, 0)
{-hw, +y, -hd, -1, 0, 0}, // 16
{-hw, +y, +hd, -1, 0, 0}, // 17
{-hw, -y, +hd, -1, 0, 0}, // 18
{-hw, -y, -hd, -1, 0, 0}, // 19
// +X 右面 (normal +1, 0, 0)
{+hw, +y, +hd, +1, 0, 0}, // 20
{+hw, +y, -hd, +1, 0, 0}, // 21
{+hw, -y, -hd, +1, 0, 0}, // 22
{+hw, -y, +hd, +1, 0, 0}, // 23
};
unsigned int idx[36] = {
0, 1, 2, 0, 2, 3, // top
4, 5, 6, 4, 6, 7, // front
8, 9, 10, 8, 10,11, // bottom
12,13,14, 12,14,15, // back
16,17,18, 16,18,19, // left
20,21,22, 20,22,23 // right
};
m_panelIndexCount = 36;
glGenVertexArrays(1, &m_panelVao);
glBindVertexArray(m_panelVao);
glGenBuffers(1, &m_panelVbo);
glBindBuffer(GL_ARRAY_BUFFER, m_panelVbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
glGenBuffers(1, &m_panelIbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_panelIbo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(idx), idx, GL_STATIC_DRAW);
// attribute layout:
// location 0: position (x,y,z)
// location 1: normal (nx,ny,nz) —— 当前 shader 没用到，先留着
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(V), (void*)(3*sizeof(float)));
glBindVertexArray(0);
}
void GLWidget::initDotGeometry_() {
// dot：使用 instanced rendering 画很多个“圆点”（本质是一个 quad + fragment shader 里 discard 成圆）
// vertex buffer 里只有一个单位 quad，instance buffer 里存每个点的位置和数值。
if (m_instanceVbo) {
glDeleteBuffers(1, &m_instanceVbo);
m_instanceVbo = 0;
}
if (m_dotsVbo) {
glDeleteBuffers(1, &m_dotsVbo);
m_dotsVbo = 0;
}
if (m_dotsVao) {
glDeleteVertexArrays(1, &m_dotsVao);
m_dotsVao = 0;
}
struct V {
float x, y;
float u, v;
};
V quad[6] = {
{-1,-1, 0,0},
{ 1,-1, 1,0},
{ 1, 1, 1,1},
{-1,-1, 0,0},
{ 1, 1, 1,1},
{-1, 1, 0,1},
};
glGenVertexArrays(1, &m_dotsVao);
glBindVertexArray(m_dotsVao);
glGenBuffers(1, &m_dotsVbo);
glBindBuffer(GL_ARRAY_BUFFER, m_dotsVbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
// attribute layout:
// location 0: quad 顶点位置 (x,y)，范围 [-1,1]
// location 1: UV (u,v)，用于 fragment shader 生成圆形
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(V), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(V), (void*)(2 * sizeof(float)));
// instance buffer：每个点 3 个 float（offsetX, offsetZ, value）
// layout location 2/3 对应 shader 里的 iOffsetXZ / iValue
glGenBuffers(1, &m_instanceVbo);
glBindBuffer(GL_ARRAY_BUFFER, m_instanceVbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * qMax(1, dotCount()), nullptr, GL_DYNAMIC_DRAW);
// location 2: vec2 iOffsetXZ（每个 instance 一次，divisor=1）
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glVertexAttribDivisor(2, 1);
// location 3: float iValue（每个 instance 一次，divisor=1）
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)(2 * sizeof(float)));
glVertexAttribDivisor(3, 1);
glBindVertexArray(0);
}
void GLWidget::initDotTexture_() {
if (m_dotTex) {
glDeleteTextures(1, &m_dotTex);
m_dotTex = 0;
}
const QString path = QStringLiteral(":/images/metal.jpeg");
QImage img(path);
if (img.isNull()) {
qWarning() << "dot texture load failed:" << path;
return;
}
QImage rgba = img.convertToFormat(QImage::Format_RGBA8888);
glGenTextures(1, &m_dotTex);
glBindTexture(GL_TEXTURE_2D, m_dotTex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGBA8,
rgba.width(),
rgba.height(),
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
rgba.constBits()
);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
}
void GLWidget::initPrograms_() {
// Qt Resource 里打包的 shader 文件路径：使用 `:/` 前缀（不是文件系统路径）
const QString vsd_path = QStringLiteral(":/shaders/dots.vert");
const QString fsd_path = QStringLiteral(":/shaders/dots.frag");
const QString vsb_path = QStringLiteral(":/shaders/bg.vert");
const QString fsb_path = QStringLiteral(":/shaders/bg.frag");
const QString vsp_path = QStringLiteral(":/shaders/panel.vert");
const QString fsp_path = QStringLiteral(":/shaders/panel.frag");
{
auto *p = new QOpenGLShaderProgram;
const bool okV = p->addShaderFromSourceCode(QOpenGLShader::Vertex, readFile(vsb_path));
const bool okF = p->addShaderFromSourceCode(QOpenGLShader::Fragment, readFile(fsb_path));
const bool okL = okV && okF && p->link();
if (!okL) {
qWarning() << "bg program build failed:" << vsb_path << fsb_path << p->log();
delete p;
p = nullptr;
}
m_bgProg = p;
}
{
auto *p = new QOpenGLShaderProgram;
const bool okV = p->addShaderFromSourceCode(QOpenGLShader::Vertex, readFile(vsp_path));
const bool okF = p->addShaderFromSourceCode(QOpenGLShader::Fragment, readFile(fsp_path));
const bool okL = okV && okF && p->link();
if (!okL) {
qWarning() << "panel program build failed:" << vsp_path << fsp_path << p->log();
delete p;
p = nullptr;
}
m_panelProg = p;
}
{
auto *p = new QOpenGLShaderProgram;
const bool okV = p->addShaderFromSourceCode(QOpenGLShader::Vertex, readFile(vsd_path));
const bool okF = p->addShaderFromSourceCode(QOpenGLShader::Fragment, readFile(fsd_path));
const bool okL = okV && okF && p->link();
if (!okL) {
qWarning() << "dots program build failed:" << vsd_path << fsd_path << p->log();
delete p;
p = nullptr;
}
m_dotsProg = p;
}
}
void GLWidget::updateInstanceBufferIfNeeded_() {
if (dotCount() <= 0) {
m_instanceCount = 0;
return;
}
QVector<float> valuesCopy;
bool dirty = false;
{
QMutexLocker lk(&m_dataMutex);
dirty = m_valuesDirty;
if (dirty) {
valuesCopy = m_latestValues;
m_valuesDirty = false;
}
}
if (!dirty)
return;
const int n = dotCount();
m_instanceCount = n;
QVector<float> inst;
// 每个点 3 个 float：offsetX, offsetZ, value（对应 dots.vert: iOffsetXZ + iValue）
inst.resize(n * 3);
const float w = (m_cols - 1) * m_pitch;
const float h = (m_rows - 1) * m_pitch;
// 把点阵居中到原点附近（x/z 以中心对称）
for (int i = 0; i < n; ++i) {
const int r = (m_cols > 0) ? (i / m_cols) : 0;
const int c = (m_cols > 0) ? (i % m_cols) : 0;
const float x = (c * m_pitch) - w * 0.5f;
const float z = (r * m_pitch) - h * 0.5f;
inst[i * 3 + 0] = x;
inst[i * 3 + 1] = z;
inst[i * 3 + 2] = (i < valuesCopy.size()) ? valuesCopy[i] : m_min;
}
// 把 CPU 生成的 instance 数据上传到 GPU（后续 draw 时由 VAO 里的 attribute 2/3 读取）
glBindBuffer(GL_ARRAY_BUFFER, m_instanceVbo);
glBufferSubData(GL_ARRAY_BUFFER, 0, inst.size() * sizeof(float), inst.constData());
}
void GLWidget::updateMatrices_() {
// MVP = Projection * View * Model
//
// OpenGL 的顶点最终要写到 gl_Position（裁剪空间），所以我们需要一个矩阵把“世界坐标”变成“屏幕可见”的坐标。
// 这里为了入门简单：
// - panel/dots 顶点数据直接当作世界坐标（Model=Identity）
// - View 用 lookAt 放一个相机
// - Projection 用透视投影（perspective）
const int w = width();
const int h = height();
if (w <= 0 || h <= 0) {
m_mvp.setToIdentity();
return;
}
const float aspect = float(w) / float(h);
const float radius = 0.5f * qSqrt(m_panelW * m_panelW + m_panelD * m_panelD);
const float distance = qMax(0.5f, radius * 2.5f);
// 让相机看向 panel 的中心点
const QVector3D center(0.0f, m_panelH * 0.5f, 0.0f);
// yaw/pitch 控制相机绕目标点“环绕”（orbit camera）
const float yawRad = qDegreesToRadians(m_camYawDeg);
const float pitchRad = qDegreesToRadians(m_camPitchDeg);
const float cosPitch = qCos(pitchRad);
const float sinPitch = qSin(pitchRad);
const QVector3D eye = center + QVector3D(
distance * cosPitch * qCos(yawRad),
distance * sinPitch,
distance * cosPitch * qSin(yawRad)
);
m_cameraPos = eye;
QMatrix4x4 view;
view.lookAt(eye, center, QVector3D(0.0f, 1.0f, 0.0f));
QMatrix4x4 proj;
// fov=45°，near=0.01，far=足够大（保证 panel + dots 在裁剪范围内）
proj.perspective(m_zoom_, aspect, 0.01f, qMax(10.0f, distance * 10.0f));
m_mvp = proj * view;
}

151
src/glwidget.h Normal file
View File

@@ -0,0 +1,151 @@
//
// Created by Lenn on 2025/12/16.
//
#ifndef TACTILEIPC3D_GLWIDGET_H
#define TACTILEIPC3D_GLWIDGET_H
#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QMutex>
#include <QOpenGLShaderProgram>
#include <QOpenGLFunctions_3_3_Core>
#include <QMatrix4x4>
#include <QVector3D>
#include <QString>
#include <atomic>
class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions_3_3_Core {
Q_OBJECT
Q_PROPERTY(float yaw READ yaw WRITE setYaw NOTIFY yawChanged)
public:
enum RenderMode {
Realistic = 0,
DataViz = 1,
};
Q_ENUM(RenderMode)
enum LabelMode {
LabelsOff = 0,
LabelsHover = 1,
LabelsAlways = 2,
};
Q_ENUM(LabelMode)
explicit GLWidget(QWidget* parent = nullptr);
~GLWidget();
// panel 的物理尺寸（单位随你：米/毫米都行，只要全程一致）
void setPanelSize(float w, float h, float d);
void setPanelThickness(float h);
// rows/cols: 传感点阵行列；pitch: 点与点的间距；dotRaius: 单个点的“显示半径”
void setSpec(int rows, int cols, float pitch, float dotRaius);
// 总点数 = 行 * 列
int dotCount() const { return m_cols * m_rows; }
// 提交一帧传感值（数量必须等于 dotCount），在 paintGL 里用 instanced 的方式绘制
void submitValues(const QVector<float>& values);
float yaw() const { return m_camYawDeg; }
public slots:
// 值域范围，用于 shader 里把 value 映射到颜色（绿->红）
void setRange(int minV, int maxV);
void setYaw(float yawDeg);
void setRenderModeString(const QString& mode);
void setLabelModeString(const QString& mode);
signals:
void yawChanged();
protected:
void initializeGL() override;
void resizeGL(int w, int h) override;
void paintGL() override;
void mousePressEvent(QMouseEvent *event) override;
void mouseMoveEvent(QMouseEvent *event) override;
void mouseReleaseEvent(QMouseEvent *event) override;
void wheelEvent(QWheelEvent *event) override;
private:
void initPanelGeometry_();
void initDotGeometry_();
void initBackgroundGeometry_();
void initPrograms_();
void initDotTexture_();
void updateInstanceBufferIfNeeded_();
void updateMatrices_();
private:
// 传感值范围（用于颜色映射）
int m_min = 0;
int m_max = 1000;
// 点阵规格
int m_rows = 3;
int m_cols = 4;
// panel: 一个长方体/板子（当前只画顶面矩形）
float m_panelW = 1.2f;
float m_panelH = 0.08f;
float m_panelD = 0.08f;
// 点阵布局参数
float m_pitch = 0.1f;
float m_dotRadius = 0.03f;
// 传感数据（GUI/定时器线程提交，GL 线程绘制）
QMutex m_dataMutex;
QVector<float> m_latestValues;
bool m_valuesDirty = false;
std::atomic<bool> m_hasData{false};
// shader program（编译/链接后的可执行 GPU 程序）
QOpenGLShaderProgram* m_bgProg = nullptr;
QOpenGLShaderProgram* m_panelProg = nullptr;
QOpenGLShaderProgram* m_dotsProg = nullptr;
unsigned int m_dotTex = 0;
// panel 的 VAO/VBO/IBO（VAO: 顶点格式/绑定状态；VBO: 顶点数据；IBO: 索引数据）
unsigned int m_panelVao = 0;
unsigned int m_panelVbo = 0;
unsigned int m_panelIbo = 0;
int m_panelIndexCount = 0;
bool m_panelGeometryDirty = false;
// dots 的 VAO/VBO + instance VBO（instance VBO 每个点一条：offsetXZ + value）
unsigned int m_dotsVao = 0;
unsigned int m_dotsVbo = 0;
unsigned int m_instanceVbo = 0;
int m_instanceCount = 0;
bool m_dotsGeometryDirty = false;
unsigned int m_bgVao = 0;
unsigned int m_bgVbo = 0;
// MVP = Projection * View * Model。
// 这里 panel/dots 顶点基本已经是“世界坐标”，所以我们用 proj*view 即可（model 先省略）。
QMatrix4x4 m_mvp;
QVector3D m_cameraPos{0.0f, 0.0f, 1.0f};
RenderMode m_renderMode = DataViz;
LabelMode m_labelMode = LabelsOff;
int m_hoveredIndex = -1;
// 早期/预留的矩阵数组（现在主要使用 QMatrix4x4 的 m_mvp，这些暂时保留做对照/扩展）
float m_proj[16]{};
float m_view[16]{};
float m_modelPanel[16]{};
float m_zoom_ = 45.0;
float m_camYawDeg = 45.0f;
float m_camPitchDeg = 35.0f;
std::atomic<bool> m_rightDown{false};
QPoint m_lastPos;
};
#endif //TACTILEIPC3D_GLWIDGET_H