WolfSpirit/EJM_Display
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity
Files
d3db641be96b293fbcedd87d9108b16e8f08dd38
EJM_Display/PublicFunctions/ObjLoader.cpp

1639 lines
64 KiB
C++
Raw Normal View History

增加3D视图
2025-09-28 17:14:34 +08:00
#include "ObjLoader.h"
#include <QVBoxLayout>
#include <QFile>
#include <QTextStream>
#include <QFileInfo>
#include <QDebug>
#include <QVBoxLayout>
#include <QSurfaceFormat>
#include <QFileInfo>
#include <QtMath>
/**
* @brief 构造函数
* 初始化3D场景相关成员变量，启动动画定时器
* @param parent 父对象
*/
ObjLoader::ObjLoader(QObject *parent)
: QObject(parent),
m_3dView(nullptr),
m_viewContainer(nullptr),
m_rootEntity(nullptr),
m_mainCamera(nullptr),
m_cameraCtrl(nullptr),
m_wholeModelEntity(nullptr),
m_wholeModelMesh(nullptr),
m_wholeModelTrans(nullptr),
m_wholeModelCenter(QVector3D(0, 0, 0)),
m_wholeModelRadius(0.0f),
m_currentMaterial(""),
m_lastError("")
{
m_animTimer = new QTimer(this);
m_animTimer->setInterval(30); // 约33fps的动画刷新频率
m_animTimer->start();
}
/**
* @brief 析构函数
* 释放所有动态分配的3D实体、变换组件和资源，避免内存泄漏
*/
ObjLoader::~ObjLoader()
{
// 1. 先销毁所有子模型（避免父模型先销毁导致子模型悬空）
QVector<QString> childDeviceNames;
for (const auto& device : m_deviceMap) {
if (!device.parentDeviceName.isEmpty()) {
childDeviceNames.append(device.name);
}
}
for (const auto& childName : childDeviceNames) {
auto it = m_deviceMap.find(childName);
if (it != m_deviceMap.end()) {
delete it->modelTransform;
delete it->transform;
delete it->modelEntity;
delete it->entity;
m_deviceMap.erase(it);
}
}
// 2. 再销毁父模型
for (auto &device : m_deviceMap) {
delete device.modelTransform;
delete device.transform;
delete device.modelEntity;
delete device.entity;
}
m_deviceMap.clear();
// 3. 清理场景资源
delete m_wholeModelEntity;
delete m_rootEntity;
delete m_3dView;
}
/**
* @brief ObjLoader::setEnDebug 是否启用qDebug打印信息
* @param En True=启用,False=禁用;
*/
void ObjLoader::setEnDebug(bool En){
EnDebug = En;
}
/**
* @brief 获取相机设备
* @return 当前创建的相机设备指针
*/
Qt3DRender::QCamera* ObjLoader::getCamera(){
return m_cameraEntity;
}
/**
* @brief 获取器件指针
* 从器件映射表中查找指定名称的器件
* @param deviceName 器件名称
* @return 找到返回Device指针，否则返回nullptr并设置错误信息
*/
Device* ObjLoader::getDevice(const QString &deviceName)
{
if (m_deviceMap.contains(deviceName)) {
return &m_deviceMap[deviceName];
}
m_lastError = "未找到器件: " + deviceName;
return nullptr;
}
/**
* @brief 设置相机控制速度
* @param lookSpeed 旋转速度
* @param linearSpeed 移动速度
*/
void ObjLoader::setCameraSpeed(float lookSpeed, float linearSpeed)
{
if (m_cameraCtrl) {
m_cameraCtrl->setLookSpeed(lookSpeed);
m_cameraCtrl->setLinearSpeed(linearSpeed);
}
}
/**
* @brief 重置相机到默认位置
* 相机位置设置为模型中心沿Z轴偏移3倍半径的位置
*/
void ObjLoader::resetCamera()
{
if (m_mainCamera && m_wholeModelRadius > 0) {
QVector3D cameraPos = m_wholeModelCenter + QVector3D(0, 0, m_wholeModelRadius * 3.0f);
m_mainCamera->setPosition(cameraPos);
m_mainCamera->setViewCenter(QVector3D(0, 0, 0));
}
}
/**
* @brief 字符串分割工具函数
* 将输入字符串按指定分隔符分割，忽略空元素
* @param s 待分割的字符串
* @param sep 分隔符（默认空格）
* @return 分割后的字符串列表
*/
QVector<QString> ObjLoader::splitStr(const QString &s, const QString &sep)
{
return s.split(sep, Qt::SkipEmptyParts).toVector();
}
/**
* @brief 初始化3D场景
* 创建3D窗口、根实体、相机、光源和控制器，设置透明背景
* @param containerWidget 用于显示3D场景的窗口容器
*/
void ObjLoader::init3DScene(QWidget *containerWidget)
{
if (!containerWidget) {
m_lastError = "无效的3D容器";
return;
}
if (EnDebug) qDebug() << "3D组件初始化" << "containerWidget" << containerWidget;
m_viewContainer = containerWidget;
// if (EnDebug) qDebug() << "3D组件初始化" << "基础容器透明设置";
// // 1. 基础容器透明设置（画框透明）
// m_viewContainer->setAttribute(Qt::WA_TranslucentBackground);
// m_viewContainer->setStyleSheet("background: transparent; border: none;");
// if (EnDebug) qDebug() << "3D组件初始化" << "配置OpenGL格式（必须启用Alpha通道以支持透明）";
// // 2. 配置OpenGL格式（必须启用Alpha通道以支持透明）
// QSurfaceFormat format = QSurfaceFormat::defaultFormat();
// format.setAlphaBufferSize(8); // 启用Alpha通道（透明的核心）
// format.setRenderableType(QSurfaceFormat::OpenGL);
// format.setVersion(3, 3);
// format.setProfile(QSurfaceFormat::CompatibilityProfile);
// QSurfaceFormat::setDefaultFormat(format);
if (EnDebug) qDebug() << "3D组件初始化" << "创建3D窗口并设置透明背景";
// 3. 创建3D窗口并设置透明背景
m_3dView = new Qt3DExtras::Qt3DWindow();
// m_3dView->setFormat(format);
if (EnDebug) qDebug() << "3D组件初始化" << "核心：3D场景背景透明（使用Qt3DExtras的QForwardRenderer）";
// 核心：3D场景背景透明（使用Qt3DExtras的QForwardRenderer）
Qt3DExtras::QForwardRenderer *frameGraph = m_3dView->defaultFrameGraph();
if (frameGraph) {
frameGraph->setClearColor(QColor(7, 19, 35)); // 全透明背景
//frameGraph->setClearColor(QColor(7, 19, 255)); // 全透明背景
}
if (EnDebug) qDebug() << "3D组件初始化" << "创建窗口容器（确保透明）";
// 4. 创建窗口容器（确保透明）
QWidget *container3D = QWidget::createWindowContainer(m_3dView, m_viewContainer);
// container3D->setAttribute(Qt::WA_TranslucentBackground);
// container3D->setStyleSheet("background: transparent !important;"); // 强制透明
// container3D->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
if (EnDebug) qDebug() << "3D组件初始化" << "布局设置";
// 5. 布局设置
QVBoxLayout *layout = new QVBoxLayout(m_viewContainer);
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(container3D);
m_viewContainer->setLayout(layout);
if (EnDebug) qDebug() << "3D组件初始化" << "3D场景核心组件（确保模型显示）";
// 6. 3D场景核心组件（确保模型显示）
m_rootEntity = new Qt3DCore::QEntity();
m_3dView->setRootEntity(m_rootEntity);
if (EnDebug) qDebug() << "3D组件初始化" << "相机设置（确保能看到物体）";
// 7. 相机设置（确保能看到物体）
m_cameraEntity = m_3dView->camera();
m_cameraEntity->setPosition(QVector3D(0, 0, 10)); // 相机初始位置（Z轴10单位处）
m_cameraEntity->setViewCenter(QVector3D(0, 0, 0)); // 看向原点
if (EnDebug) qDebug() << "3D组件初始化" << "相机控制器（可拖动旋转查看）";
// 8. 相机控制器（可拖动旋转查看）
Qt3DExtras::QOrbitCameraController *controller = new Qt3DExtras::QOrbitCameraController(m_rootEntity);
controller->setCamera(m_cameraEntity);
if (EnDebug) qDebug() << "3D组件初始化" << "光源（确保模型可见）";
// 9. 光源（确保模型可见）
Qt3DCore::QEntity *lightEntity = new Qt3DCore::QEntity(m_cameraEntity);
light = new Qt3DRender::QDirectionalLight(lightEntity);
light->setColor(Qt::white);
light->setIntensity(1.5f); // 光源强度
lightEntity->addComponent(light);
Qt3DCore::QTransform *lightTransform = new Qt3DCore::QTransform(lightEntity);
lightTransform->setTranslation(m_cameraEntity->position()); // 光源位置与相机一致
lightEntity->addComponent(lightTransform);
}
/**
* @brief 初始化3D场景
* 创建3D窗口、根实体、相机、光源和控制器，支持透明背景、场景占满容器、尺寸同步
* @param containerWidget 用于显示3D场景的窗口容器（如QFrame）
* @param enableTransparent 是否启用场景背景透明（true=透明，false=纯色背景）
* @return 初始化成功返回true，失败返回false（可通过lastError()获取错误信息）
*/
bool ObjLoader::init3DScene(QWidget *containerWidget, bool enableTransparent)
{
// 1. 基础校验与初始化
if (!containerWidget) {
m_lastError = "3D场景初始化失败：容器Widget为空";
if (EnDebug) qCritical() << m_lastError;
return false;
}
m_viewContainer = containerWidget;
const QString containerName = m_viewContainer->objectName();
if (EnDebug) qDebug() << "[3D初始化] 目标容器：" << containerName
<< "，初始尺寸：" << m_viewContainer->size();
// 2. 强制解除父容器的尺寸约束（核心！解决Frame默认尺寸限制）
m_viewContainer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); // 允许拉伸
m_viewContainer->setMinimumSize(0, 0); // 取消最小尺寸限制（避免Frame默认固定大小）
m_viewContainer->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX); // 取消最大尺寸限制
m_viewContainer->setContentsMargins(0, 0, 0, 0); // 容器自身无内边距
// 强制父容器立即刷新尺寸（避免UI缓存导致的延迟）
m_viewContainer->updateGeometry();
m_viewContainer->repaint();
// 3. 透明模式配置（按需启用）
if (enableTransparent) {
m_viewContainer->setAttribute(Qt::WA_TranslucentBackground, true);
m_viewContainer->setStyleSheet("QFrame{background: transparent; border: none; padding: 0px; margin: 0px;}");
} else {
m_viewContainer->setStyleSheet("QFrame{background: #071323; border: none; padding: 0px; margin: 0px;}");
}
// 4. OpenGL格式配置（确保渲染兼容性）
QSurfaceFormat glFormat = QSurfaceFormat::defaultFormat();
glFormat.setRenderableType(QSurfaceFormat::OpenGL);
glFormat.setVersion(3, 3);
glFormat.setProfile(QSurfaceFormat::CompatibilityProfile);
if (enableTransparent) {
glFormat.setAlphaBufferSize(8);
glFormat.setDepthBufferSize(24);
}
QSurfaceFormat::setDefaultFormat(glFormat);
// 5. 创建3D窗口与渲染容器（强制占满）
m_3dView = new Qt3DExtras::Qt3DWindow();
m_3dView->setFormat(glFormat);
// 配置3D场景背景
Qt3DExtras::QForwardRenderer *frameGraph = m_3dView->defaultFrameGraph();
if (!frameGraph) {
m_lastError = "3D场景初始化失败：获取帧图失败";
delete m_3dView;
return false;
}
frameGraph->setClearColor(enableTransparent ? QColor(0,0,0,0) : QColor(7,19,35));
// 6. 3D容器：强制拉伸+无间隙（关键！）
QWidget *container3D = QWidget::createWindowContainer(m_3dView, m_viewContainer);
container3D->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); // 最高拉伸优先级
container3D->setContentsMargins(0, 0, 0, 0); // 容器无内边距
container3D->setStyleSheet("background: transparent; padding: 0px; margin: 0px;");
// 强制3D容器初始尺寸与父容器完全一致（避免初始空白）
container3D->resize(m_viewContainer->size());
if (EnDebug) qDebug() << "[3D初始化] 3D容器初始尺寸：" << container3D->size();
// 7. 布局：锁定3D容器为唯一子组件（无任何间隙）
// 先清除父容器原有布局（避免Qt Designer残留布局冲突）
QLayout *oldLayout = m_viewContainer->layout();
if (oldLayout) {
oldLayout->deleteLater(); // 删除旧布局
if (EnDebug) qDebug() << "[3D初始化] 已清除容器原有布局";
}
// 创建新布局并锁定3D容器
QVBoxLayout *sceneLayout = new QVBoxLayout(m_viewContainer);
sceneLayout->setContentsMargins(0, 0, 0, 0); // 布局无内边距
sceneLayout->setSpacing(0); // 布局无间距
sceneLayout->setSizeConstraint(QLayout::SetFixedSize); // 布局尺寸跟随父容器
sceneLayout->addWidget(container3D);
// 强制布局立即生效
sceneLayout->activate();
m_viewContainer->setLayout(sceneLayout);
// 8. 3D场景核心组件（根实体+相机+光源+控制器）
m_rootEntity = new Qt3DCore::QEntity();
m_3dView->setRootEntity(m_rootEntity);
// 相机：确保视野正常
m_cameraEntity = m_3dView->camera();
m_cameraEntity->setPosition(QVector3D(0, 0, 20));
m_cameraEntity->setViewCenter(QVector3D(0, 0, 0));
m_cameraEntity->setAspectRatio(float(m_viewContainer->width()) / float(m_viewContainer->height()));
// 控制器：支持鼠标交互
Qt3DExtras::QOrbitCameraController *camController = new Qt3DExtras::QOrbitCameraController(m_rootEntity);
camController->setCamera(m_cameraEntity);
// 光源：确保模型可见
Qt3DCore::QEntity *lightEntity = new Qt3DCore::QEntity(m_rootEntity);
light = new Qt3DRender::QDirectionalLight(lightEntity);
light->setColor(Qt::white);
light->setIntensity(2.0f);
light->setWorldDirection(QVector3D(-1, -2, -3).normalized());
lightEntity->addComponent(light);
Qt3DCore::QTransform *lightTransform = new Qt3DCore::QTransform(lightEntity);
lightTransform->setTranslation(QVector3D(10, 20, 30));
lightEntity->addComponent(lightTransform);
QTimer::singleShot(10, this, [this, containerPtr = m_viewContainer]() {
if (!containerPtr || !containerPtr->layout()) return;
QWidget *container3D = containerPtr->layout()->itemAt(0)->widget();
if (!container3D) return;
// 1. 实时获取父容器的初始有效尺寸（排除0x0）
QSize parentSize = containerPtr->contentsRect().size();
QSize validInitialSize = (parentSize.width() > 0 && parentSize.height() > 0)
? parentSize
: QSize(420, 230); // 兜底尺寸（匹配日志初始值）
// 2. 实时获取父容器当前尺寸（避免被外部缩小）
QSize currentParentSize = containerPtr->contentsRect().size();
QSize validCurrentSize = (currentParentSize.width() > 0 && currentParentSize.height() > 0)
? currentParentSize
: validInitialSize;
// 3. 最终尺寸：取“有效初始尺寸”和“当前有效尺寸”的最大值（禁止缩小）
QSize finalSize = validCurrentSize.expandedTo(validInitialSize);
container3D->resize(finalSize);
// 4. 同步相机宽高比（避免模型拉伸）
if (m_cameraEntity && finalSize.width() > 0 && finalSize.height() > 0) {
m_cameraEntity->setAspectRatio(float(finalSize.width()) / float(finalSize.height()));
}
// 调试日志：明确各尺寸来源
if (EnDebug) {
qDebug() << "[3D尺寸同步] 有效初始尺寸:" << validInitialSize
<< "，当前父容器尺寸:" << currentParentSize
<< "，最终锁定尺寸:" << finalSize;
}
});
return true;
}
/**
* @brief 加载器件（独立模型）
* 创建双层实体结构（外层控制位置，内层控制旋转/缩放），解析并应用MTL材质
* @param deviceName 器件名称
* @param filePath OBJ文件路径
* @param position 初始位置
* @return 加载成功返回true
*/
bool ObjLoader::loadDevice(const QString &deviceName, const QString &filePath, const QVector3D &position)
{
if (m_deviceMap.contains(deviceName)) {
m_lastError = "器件名称已存在: " + deviceName;
return false;
}
if (!m_rootEntity) {
m_lastError = "3D场景未初始化，请先调用init3DScene";
return false;
}
QFileInfo testFile(filePath);
if(!testFile.exists()){
m_lastError = "文件不存在: " + filePath;
if (EnDebug) qDebug() << filePath<<"设备 文件是否存在：" << testFile.exists() << "，绝对路径：" << testFile.absoluteFilePath();
return false;
}
// 1. 计算模型几何中心（用于预中心化，使旋转围绕模型自身中心）
QVector3D modelCenter = parseObjCenter(filePath);
float modelRadius = calculateModelRadiusFromFile(filePath);
if (EnDebug) qDebug() << "模型几何中心: " << modelCenter << " 模型半径: " << modelRadius;
// 2. 创建双层实体结构
Qt3DCore::QEntity *deviceEntity = new Qt3DCore::QEntity(m_rootEntity); // 外层实体
Qt3DCore::QTransform *deviceTransform = new Qt3DCore::QTransform();
deviceTransform->setTranslation(position); // 外层控制世界位置
deviceEntity->addComponent(deviceTransform);
// 内层实体：控制旋转和缩放
Qt3DCore::QEntity *modelEntity = new Qt3DCore::QEntity(deviceEntity);
Qt3DCore::QTransform *modelTransform = new Qt3DCore::QTransform();
modelTransform->setTranslation(-modelCenter); // 预中心化（将模型中心移至局部原点）
modelEntity->addComponent(modelTransform);
// 3. 加载模型网格
Qt3DRender::QMesh *deviceMesh = new Qt3DRender::QMesh();
deviceMesh->setSource(QUrl::fromLocalFile(filePath));
modelEntity->addComponent(deviceMesh);
// 4. 加载并应用MTL材质
Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial();
material->setDiffuse(QColor(0, 255, 255,80)); // 默认白色
modelEntity->addComponent(material);
// 5. 存储器件信息
Device device;
device.name = deviceName;
device.entity = deviceEntity;
device.modelEntity = modelEntity;
device.transform = deviceTransform;
device.modelTransform = modelTransform;
device.worldPosition = position;
device.originalPosition = position;
device.currentRotation = QVector3D(0, 0, 0);
device.modelCenter = modelCenter;
device.scale = 1.0f;
device.isInitialized = true;
m_deviceMap[deviceName] = device;
return true;
}
bool ObjLoader::loadModel(const QString &deviceName, const QString &filePath, const QVector3D &position)
{
if (m_deviceMap.contains(deviceName)) {
m_lastError = "器件名称已存在: " + deviceName;
return false;
}
if (!m_rootEntity) {
m_lastError = "3D场景未初始化，请先调用init3DScene";
return false;
}
QFileInfo testFile(filePath);
if(!testFile.exists()){
m_lastError = "文件不存在: " + filePath;
if (EnDebug) qDebug() << filePath<<"设备 文件是否存在：" << testFile.exists() << "，绝对路径：" << testFile.absoluteFilePath();
return false;
}
// 1. 计算模型几何中心和半径
QVector3D modelCenter = parseObjCenter(filePath);
float modelRadius = calculateModelRadiusFromFile(filePath);
if (EnDebug) qDebug() << "模型几何中心: " << modelCenter << " 模型半径: " << modelRadius;
// 2. 创建双层实体结构
Qt3DCore::QEntity *deviceEntity = new Qt3DCore::QEntity(m_rootEntity);
Qt3DCore::QTransform *deviceTransform = new Qt3DCore::QTransform();
QVector3D outerTranslation = position - modelCenter;
deviceTransform->setTranslation(outerTranslation);
deviceEntity->addComponent(deviceTransform);
Qt3DCore::QEntity *modelEntity = new Qt3DCore::QEntity(deviceEntity);
Qt3DCore::QTransform *modelTransform = new Qt3DCore::QTransform();
modelTransform->setTranslation(modelCenter);
modelEntity->addComponent(modelTransform);
// 3. 加载模型网格
Qt3DRender::QMesh *deviceMesh = new Qt3DRender::QMesh();
deviceMesh->setSource(QUrl::fromLocalFile(filePath));
modelEntity->addComponent(deviceMesh);
// 4. 加载并应用MTL材质
Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial();
QFile objFile(filePath);
if (objFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
QTextStream stream(&objFile);
QString mtlPath; // MTL文件路径
QString useMtl; // 当前使用的材质名称
while (!stream.atEnd()) {
QString line = stream.readLine().trimmed();
if (line.startsWith("mtllib")) {
// 解析MTL文件路径
QStringList parts = line.split(" ");
if (parts.size() >= 2) {
mtlPath = QFileInfo(filePath).path() + "/" + parts[1];
parseMtlFile(mtlPath); // 解析MTL文件到m_materials
}
} else if (line.startsWith("usemtl")) {
// 解析当前使用的材质名称
QStringList parts = line.split(" ");
if (parts.size() >= 2) {
useMtl = parts[1];
}
}
}
objFile.close();
// 应用解析到的材质
if (m_materials.contains(useMtl)) {
Material mtl = m_materials[useMtl];
material->setAmbient(mtl.ambient);
material->setDiffuse(mtl.diffuse);
material->setSpecular(mtl.specular);
material->setShininess(mtl.shininess);
// 设置透明度（通过漫反射颜色的alpha通道）
QColor diffuse = mtl.diffuse;
diffuse.setAlphaF(mtl.opacity); // 0.0~1.0范围
material->setDiffuse(diffuse);
// 同时设置环境光的alpha（可选）
QColor ambient = mtl.ambient;
ambient.setAlphaF(mtl.opacity);
material->setAmbient(ambient);
if(EnDebug) qDebug() << "应用材质: " << useMtl << " 到设备: " << deviceName;
} else {
if(EnDebug) qDebug() << "未找到材质: " << useMtl << "，使用默认材质";
material->setDiffuse(QColor(255, 255, 255,50)); // 默认白色
}
}
// 5. 存储器件信息
Device device;
device.name = deviceName;
device.entity = deviceEntity;
device.modelEntity = modelEntity;
device.transform = deviceTransform;
device.modelTransform = modelTransform;
device.worldPosition = position;
device.originalPosition = position;
device.currentRotation = QVector3D(0, 0, 0);
device.modelCenter = modelCenter;
device.scale = 1.0f;
device.isInitialized = true;
m_deviceMap[deviceName] = device;
return true;
}
/**
* @brief 加载器件（独立模型）
* 创建双层实体结构（外层控制位置，内层控制旋转/缩放），解析并应用MTL材质
* 加载完成后自动调整相机位置，确保模型可见
* @param deviceName 器件名称
* @param filePath OBJ文件路径
* @param position 初始位置
* @return 加载成功返回true
*/
//bool ObjLoader::loadModel(const QString &deviceName, const QString &filePath, const QVector3D &position)
//{
// if (m_deviceMap.contains(deviceName)) {
// m_lastError = "器件名称已存在: " + deviceName;
// return false;
// }
// if (!m_rootEntity) {
// m_lastError = "3D场景未初始化，请先调用init3DScene";
// return false;
// }
// // 1. 计算模型几何中心和顶点数据
// QVector3D modelCenter = parseObjCenter(filePath);
// float modelRadius = calculateModelRadiusFromFile(filePath);
// if(EnDebug) qDebug() << "模型几何中心: " << modelCenter << " 顶点数据: " << modelRadius;
// // 2. 创建双层实体结构（关键修改：修正坐标变换逻辑）
// Qt3DCore::QEntity *deviceEntity = new Qt3DCore::QEntity(m_rootEntity);
// Qt3DCore::QTransform *deviceTransform = new Qt3DCore::QTransform();
// // 核心修复：外层平移 = 目标位置 - 模型局部中心
// // 确保模型几何中心与传入的position对齐
// QVector3D outerTranslation = position - modelCenter;
// deviceTransform->setTranslation(outerTranslation);
// deviceEntity->addComponent(deviceTransform);
// // 内层实体：抵消模型自身偏移，确保旋转中心正确
// Qt3DCore::QEntity *modelEntity = new Qt3DCore::QEntity(deviceEntity);
// Qt3DCore::QTransform *modelTransform = new Qt3DCore::QTransform();
// modelTransform->setTranslation(modelCenter); // 关键：与外层平移形成抵消
// modelEntity->addComponent(modelTransform);
// // 3. 加载模型网格
// Qt3DRender::QMesh *deviceMesh = new Qt3DRender::QMesh();
// deviceMesh->setSource(QUrl::fromLocalFile(filePath));
// modelEntity->addComponent(deviceMesh);
// // 4. 加载并应用MTL材质
// Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial();
// QFile objFile(filePath);
// if (objFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
// QTextStream stream(&objFile);
// QString mtlPath; // MTL文件路径
// QString useMtl; // 当前使用的材质名称
// while (!stream.atEnd()) {
// QString line = stream.readLine().trimmed();
// if (line.startsWith("mtllib")) {
// // 解析MTL文件路径
// QStringList parts = line.split(" ");
// if (parts.size() >= 2) {
// mtlPath = QFileInfo(filePath).path() + "/" + parts[1];
// parseMtlFile(mtlPath); // 解析MTL文件到m_materials
// }
// } else if (line.startsWith("usemtl")) {
// // 解析当前使用的材质名称
// QStringList parts = line.split(" ");
// if (parts.size() >= 2) {
// useMtl = parts[1];
// }
// }
// }
// objFile.close();
// // 应用解析到的材质
// if (m_materials.contains(useMtl)) {
// Material mtl = m_materials[useMtl];
// material->setAmbient(mtl.ambient);
// material->setDiffuse(mtl.diffuse);
// material->setSpecular(mtl.specular);
// material->setShininess(mtl.shininess);
// // 设置透明度（通过漫反射颜色的alpha通道）
// QColor diffuse = mtl.diffuse;
// diffuse.setAlphaF(mtl.opacity); // 0.0~1.0范围
// material->setDiffuse(diffuse);
// // 同时设置环境光的alpha（可选）
// QColor ambient = mtl.ambient;
// ambient.setAlphaF(mtl.opacity);
// material->setAmbient(ambient);
// if(EnDebug) qDebug() << "应用材质: " << useMtl << " 到设备: " << deviceName;
// } else {
// if(EnDebug) qDebug() << "未找到材质: " << useMtl << "，使用默认材质";
// material->setDiffuse(QColor(0, 255, 255,10)); // 默认白色
// }
// }
// modelEntity->addComponent(material);
// // 5. 存储器件信息
// Device device;
// device.name = deviceName;
// device.entity = deviceEntity;
// device.modelEntity = modelEntity;
// device.transform = deviceTransform;
// device.modelTransform = modelTransform;
// device.worldPosition = position;
// device.originalPosition = position;
// device.currentRotation = QVector3D(0, 0, 0);
// device.modelCenter = modelCenter;
// device.scale = 1.0f;
// device.isInitialized = true;
// m_deviceMap[deviceName] = device;
// return true;
//}
/**
* @brief 从OBJ文件计算模型的包围球半径
* 解析OBJ文件中的顶点数据，计算模型几何中心到最远顶点的距离，作为模型的包围球半径
* 该半径用于确定相机与模型的合适距离，确保模型能完整显示在视野中
* @param filePath OBJ模型文件的路径
* @return 模型包围球半径（单位与模型顶点坐标一致），若文件解析失败则返回1.0f默认值
*/
float ObjLoader::calculateModelRadiusFromFile(const QString &filePath)
{
QVector<QVector3D> vertices;
QFile objFile(filePath);
if (!objFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
m_lastError = "无法打开OBJ文件计算半径: " + filePath;
return 1.0f; // 默认半径
}
QTextStream fileStream(&objFile);
while (!fileStream.atEnd()) {
QString line = fileStream.readLine().trimmed();
if (line.isEmpty() || line.startsWith('#')) continue;
QVector<QString> lineParts = splitStr(line);
if (lineParts.isEmpty()) continue;
// 只解析顶点位置（"v x y z"格式）
if (lineParts[0] == "v" && lineParts.size() >= 4) {
vertices.append(QVector3D(
lineParts[1].toFloat(),
lineParts[2].toFloat(),
lineParts[3].toFloat()
));
}
}
objFile.close();
// 如果没有顶点数据，返回默认半径
if (vertices.isEmpty()) return 1.0f;
// 计算模型中心
QVector3D center = calculateBoundingBoxCenter(vertices);
// 找到距离中心最远的顶点，计算半径
float maxDistance = 0.0f;
for (const auto& v : vertices) {
float distance = (v - center).length();
if (distance > maxDistance) {
maxDistance = distance;
}
}
return maxDistance;
}
/**
* @brief 加载子器件（挂载到父器件下）
* 确保子器件与父器件的初始相对位置正确，并继承父器件的变换
* @param childDeviceName 子器件名称
* @param filePath OBJ文件路径
* @param parentDeviceName 父器件名称
* @param offsetDir 相对父器件的偏移方向
* @param diffuse 材质
* @return 加载成功返回true
*/
bool ObjLoader::loadChildDevice(
const QString &childDeviceName,
const QString &filePath,
const QString &parentDeviceName,
const QVector3D &offsetDir,
const QColor &diffuse
)
{
// 基础校验
if (m_deviceMap.contains(childDeviceName)) {
m_lastError = "子设备名称已存在: " + childDeviceName;
return false;
}
if (!m_rootEntity) {
m_lastError = "3D场景未初始化";
return false;
}
// 获取父设备（摇臂）
Device* parentDevice = getDevice(parentDeviceName);
if (!parentDevice || !parentDevice->isInitialized) {
m_lastError = "父设备不存在或未初始化: " + parentDeviceName;
return false;
}
QFileInfo testFile(filePath);
if(!testFile.exists()){
m_lastError = "文件不存在: " + parentDeviceName;
if (EnDebug) qDebug() << childDeviceName<<"设备 文件是否存在：" << testFile.exists() << "，绝对路径：" << testFile.absoluteFilePath();
return false;
}
// 计算子设备（滚筒）的几何中心
QVector3D childModelCenter = parseObjCenter(filePath);
// 精确计算相对偏移：确保父设备与子设备的几何中心相对位置正确
QVector3D modelCenter = parseObjCenter(filePath); //世界模型中心
QVector3D parentCenter = parentDevice->modelCenter; // 父设备几何中心
QVector3D installOffset = parentCenter + offsetDir - childModelCenter;// 模型几何中心
float modelRadius = calculateModelRadiusFromFile(filePath);//顶点
if (EnDebug) qDebug() << "模型几何中心: " << modelCenter << "父设备几何中心" <<parentCenter<<"模型几何中心"<<installOffset<< " 顶点位置: " << modelRadius;
// 创建子设备实体（挂载到父设备实体下，形成层级关系）
Qt3DCore::QEntity* childEntity = new Qt3DCore::QEntity(parentDevice->entity);
Qt3DCore::QTransform* childTransform = new Qt3DCore::QTransform();
childTransform->setTranslation(installOffset); // 设置精确计算的偏移
childEntity->addComponent(childTransform);
// 创建子设备模型实体（内层，处理旋转和缩放）
Qt3DCore::QEntity* childModelEntity = new Qt3DCore::QEntity(childEntity);
Qt3DCore::QTransform* childModelTrans = new Qt3DCore::QTransform();
childModelTrans->setTranslation(-childModelCenter); // 子模型预中心化
childModelEntity->addComponent(childModelTrans);
// 加载网格和材质
Qt3DRender::QMesh* childMesh = new Qt3DRender::QMesh();
childMesh->setSource(QUrl::fromLocalFile(filePath));
childModelEntity->addComponent(childMesh);
// 4. 加载并应用MTL材质
Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial();
material->setDiffuse(diffuse); // 默认白色
// // 加载MTL材质
// Qt3DExtras::QPhongMaterial* childMat = new Qt3DExtras::QPhongMaterial();
// QString mtlPath; // MTL文件路径（从OBJ中读取）
// QString useMtlName; // 子设备使用的材质名称（从OBJ中读取）
// QString objBaseDir = QFileInfo(filePath).path() + "/"; // OBJ文件所在目录
// // 解析OBJ文件，提取MTL路径和当前使用的材质名称
// QFile objFile(filePath);
// if (objFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
// QTextStream objStream(&objFile);
// while (!objStream.atEnd()) {
// QString line = objStream.readLine().trimmed();
// if (line.isEmpty() || line.startsWith('#')) continue; // 跳过注释和空行
// QVector<QString> lineParts = splitStr(line);
// if (lineParts.isEmpty()) continue;
// QString cmd = lineParts[0];
// // 读取MTL文件路径（OBJ中的"mtllib"指令）
// if (cmd == "mtllib" && lineParts.size() >= 2) {
// mtlPath = objBaseDir + lineParts[1]; // 拼接MTL的绝对路径
// if (QFile::exists(mtlPath)) {
// parseMtlFile(mtlPath); // 解析MTL文件，存入m_materials
// if(EnDebug) qDebug() << "[子设备材质] 已解析MTL文件：" << mtlPath;
// } else {
// qWarning() << "[子设备材质] MTL文件不存在：" << mtlPath;
// }
// }
// // 读取当前使用的材质名称（OBJ中的"usemtl"指令）
// else if (cmd == "usemtl" && lineParts.size() >= 2) {
// useMtlName = lineParts[1]; // 记录子设备要使用的材质名称
// if(EnDebug) qDebug() << "[子设备材质] 子设备" << childDeviceName << "使用材质：" << useMtlName;
// }
// }
// objFile.close();
// } else {
// qWarning() << "[子设备材质] 无法打开OBJ文件：" << filePath;
// }
// // 应用MTL材质（优先使用解析到的材质，无则用默认颜色）
// if (!useMtlName.isEmpty() && m_materials.contains(useMtlName)) {
// Material mtl = m_materials[useMtlName];
// childMat->setAmbient(mtl.ambient);
// childMat->setDiffuse(mtl.diffuse);
// childMat->setSpecular(mtl.specular);
// childMat->setShininess(mtl.shininess);
// // 设置透明度（通过漫反射颜色的alpha通道）
// QColor diffuseWithAlpha = mtl.diffuse;
// diffuseWithAlpha.setAlphaF(mtl.opacity);
// childMat->setDiffuse(diffuseWithAlpha);
// if(EnDebug) qDebug() << "[子设备材质] 成功应用MTL材质：" << useMtlName
// << " | 漫反射颜色：" << mtl.diffuse
// << " | 透明度：" << mtl.opacity;
// } else {
// // fallback：使用默认颜色
// childMat->setDiffuse(QColor(100, 200, 255));
// if(EnDebug) qDebug() << "[子设备材质] 未找到指定材质，使用默认颜色：(100,200,255)";
// }
childModelEntity->addComponent(material); // 将材质添加到子设备模型实体
// 初始化子设备信息
Device childDevice;
childDevice.name = childDeviceName;
childDevice.entity = childEntity;
childDevice.modelEntity = childModelEntity;
childDevice.transform = childTransform;
childDevice.modelTransform = childModelTrans;
childDevice.worldPosition = parentDevice->worldPosition + installOffset;
childDevice.currentRotation = QVector3D(0, 0, 0);
childDevice.modelCenter = childModelCenter;
childDevice.scale = 1.0f;
childDevice.isInitialized = true;
childDevice.parentDeviceName = parentDeviceName;
childDevice.offsetToParent = installOffset; // 记录初始相对偏移
// 保存初始状态（用于后续精确复位）
childDevice.initialWorldPosition = childDevice.worldPosition;
childDevice.initialRotation = childDevice.currentRotation;
childDevice.initialTransformMatrix = childTransform->matrix();
childDevice.initialModelTransformMatrix = childModelTrans->matrix();
m_deviceMap[childDeviceName] = childDevice;
qInfo() << "子设备" << childDeviceName << "已挂载到" << parentDeviceName
<< "，初始相对偏移：" << installOffset;
return true;
}
/**
* @brief 旋转器件（绕自身中心）
* 将角度转换为弧度后应用到内层变换组件
* @param deviceName 器件名称
* @param xAngle X轴旋转角度（度）
* @param yAngle Y轴旋转角度（度）
* @param zAngle Z轴旋转角度（度）
*/
void ObjLoader::rotateDevice(const QString &deviceName, float xAngle, float yAngle, float zAngle)
{
Device *device = getDevice(deviceName);
if (!device || !device->isInitialized) return;
// 打印传入的角度值（调试用）
if(EnDebug) qDebug() << "接收旋转参数：" << xAngle << "," << yAngle << "," << zAngle;
device->currentRotation = QVector3D(xAngle, yAngle, zAngle);
// 角度→弧度（Qt3D的旋转函数接受弧度）
float xRad = xAngle * M_PI / 180.0f;
float yRad = yAngle * M_PI / 180.0f;
float zRad = zAngle * M_PI / 180.0f;
// 应用旋转到内层变换（同时保持缩放）
device->modelTransform->setRotationX(xRad);
device->modelTransform->setRotationY(yRad);
device->modelTransform->setRotationZ(zRad);
device->modelTransform->setScale(device->scale);
}
/**
* @brief 移动器件（相对偏移）
* 更新器件的世界位置并应用到外层变换
* @param deviceName 器件名称
* @param offset 偏移量（世界坐标）
*/
void ObjLoader::moveDevice(const QString &deviceName, const QVector3D &offset)
{
Device *device = getDevice(deviceName);
if (!device || !device->isInitialized) return;
// 更新世界位置
device->worldPosition += offset;
device->transform->setTranslation(device->worldPosition);
}
/**
* @brief 设置器件位置（绝对位置）
* 直接设置器件的世界位置并应用到外层变换
* @param deviceName 器件名称
* @param targetPos 目标位置（世界坐标）
*/
void ObjLoader::setDevicePos(const QString &deviceName, const QVector3D &targetPos)
{
Device *device = getDevice(deviceName);
if (!device || !device->isInitialized) return;
// 更新世界位置
device->worldPosition = targetPos;
device->transform->setTranslation(device->worldPosition);
}
/**
* @brief 缩放器件
* 更新缩放因子并重新应用变换（确保旋转状态保持）
* @param deviceName 器件名称
* @param scaleFactor 缩放因子（>0）
*/
void ObjLoader::scaleDevice(const QString &deviceName, float scaleFactor)
{
if (scaleFactor <= 0) return;
Device *device = getDevice(deviceName);
if (!device || !device->isInitialized) return;
// 保存新的缩放因子
device->scale = scaleFactor;
// 重新应用变换（保持当前旋转角度）
rotateDevice(deviceName,
device->currentRotation.x(),
device->currentRotation.y(),
device->currentRotation.z());
}
/**
* @brief 重置器件到初始状态
* 恢复初始位置、旋转和缩放
* @param deviceName 器件名称
*/
void ObjLoader::resetDevice(const QString &deviceName)
{
Device *device = getDevice(deviceName);
if (!device || !device->isInitialized) return;
// 重置所有属性
device->worldPosition = device->originalPosition;
device->currentRotation = QVector3D(0, 0, 0);
device->scale = 1.0f;
// 应用重置后的变换
device->transform->setTranslation(device->worldPosition);
rotateDevice(deviceName, 0, 0, 0);
}
/**
* @brief 从数据映射更新多个器件的属性
* 支持同时更新缩放、旋转和位置
* @param deviceData 器件数据映射
*/
void ObjLoader::updateDevicesFromData(const QMap<QString, QMap<QString, float>> &deviceData)
{
for (auto it = deviceData.begin(); it != deviceData.end(); ++it) {
const QString &deviceName = it.key();
const QMap<QString, float> &data = it.value();
// 处理缩放数据
if (data.contains("scale")) {
scaleDevice(deviceName, data["scale"]);
}
// 处理旋转数据
if (data.contains("xRot") && data.contains("yRot") && data.contains("zRot")) {
rotateDevice(deviceName,
data["xRot"],
data["yRot"],
data["zRot"]);
}
// 处理位置数据
if (data.contains("xPos") && data.contains("yPos") && data.contains("zPos")) {
setDevicePos(deviceName, QVector3D(
data["xPos"],
data["yPos"],
data["zPos"]
));
}
}
}
/**
* @brief 设置父器件位置（影响子器件）
* 无父级的器件直接设置位置，有子级的器件通过调整偏移更新
* @param deviceName 器件名称
* @param position 目标位置（世界坐标）
*/
void ObjLoader::setParentDevicePosition(const QString &deviceName, const QVector3D &position)
{
Device *device = getDevice(deviceName);
if (!device || !device->isInitialized) {
m_lastError = "模型不存在或未初始化: " + deviceName;
return;
}
// 只有无父级的模型才直接设置位置
if (device->parentDeviceName.isEmpty()) {
device->worldPosition = position;
device->transform->setTranslation(position); // 直接修改世界坐标
} else {
// 如果是子模型，使用相对偏移方法
adjustChildDeviceOffset(deviceName, position);
}
}
/**
* @brief 添加坐标轴 gizmo
* 创建X（红）、Y（绿）、Z（蓝）三条坐标轴，端点带小球标记
* @param parent 父实体（默认根实体）
* @param length 坐标轴长度
*/
void ObjLoader::addAxisGizmo(Qt3DCore::QEntity *parent, float length)
{
if (!parent) parent = m_rootEntity; // 如果未指定父实体，使用根实体
if (!parent) return; // 确保父实体有效
// 创建单个轴的辅助函数（使用内置材质）
auto createAxis = [&](const QVector3D& end, const QColor& color) {
// 1. 创建线段几何
Qt3DRender::QGeometry *geometry = new Qt3DRender::QGeometry();
// 顶点数据（从原点到终点）
QByteArray vertexData;
vertexData.resize(2 * 3 * sizeof(float)); // 2个点，每个点3个坐标
float *vertices = reinterpret_cast<float*>(vertexData.data());
// 起点（原点）
vertices[0] = 0.0f;
vertices[1] = 0.0f;
vertices[2] = 0.0f;
// 终点
vertices[3] = end.x();
vertices[4] = end.y();
vertices[5] = end.z();
// 创建顶点缓冲
Qt3DRender::QBuffer *vertexBuffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::VertexBuffer);
vertexBuffer->setData(vertexData);
// 创建位置属性
Qt3DRender::QAttribute *positionAttribute = new Qt3DRender::QAttribute();
positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float);
positionAttribute->setVertexSize(3);
positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
positionAttribute->setBuffer(vertexBuffer);
positionAttribute->setByteOffset(0);
positionAttribute->setByteStride(3 * sizeof(float));
positionAttribute->setCount(2);
geometry->addAttribute(positionAttribute);
// 2. 创建线段渲染器
Qt3DRender::QGeometryRenderer *renderer = new Qt3DRender::QGeometryRenderer();
renderer->setGeometry(geometry);
renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
// 3. 使用内置材质（避免自定义着色器）
Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial();
material->setDiffuse(color);
material->setAmbient(color);
material->setSpecular(color);
material->setShininess(1.0f);
// 4. 创建线段实体
Qt3DCore::QEntity *axisEntity = new Qt3DCore::QEntity(parent);
axisEntity->addComponent(renderer);
axisEntity->addComponent(material);
// 5. 在轴的端点添加一个小球标记
Qt3DCore::QEntity *marker = new Qt3DCore::QEntity(axisEntity);
Qt3DExtras::QSphereMesh *markerMesh = new Qt3DExtras::QSphereMesh();
markerMesh->setRadius(length * 0.05f); // 小球半径为轴长的5%
marker->addComponent(markerMesh);
Qt3DCore::QTransform *markerTransform = new Qt3DCore::QTransform();
markerTransform->setTranslation(end);
marker->addComponent(markerTransform);
Qt3DExtras::QPhongMaterial *markerMat = new Qt3DExtras::QPhongMaterial();
markerMat->setDiffuse(color);
marker->addComponent(markerMat);
return axisEntity;
};
// 创建三条坐标轴
createAxis(QVector3D(length, 0, 0), Qt::red); // X轴（红色）
createAxis(QVector3D(0, length, 0), Qt::green); // Y轴（绿色）
createAxis(QVector3D(0, 0, length), Qt::blue); // Z轴（蓝色）
}
/**
* @brief 解析OBJ文件计算模型中心
* 读取OBJ文件中的顶点数据，计算包围盒中心
* @param filePath OBJ文件路径
* @return 模型中心坐标（局部坐标系）
*/
QVector3D ObjLoader::parseObjCenter(const QString &filePath)
{
QVector<QVector3D> vertices;
QFile objFile(filePath);
if (!objFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
m_lastError = "无法打开OBJ文件计算中心: " + filePath;
return QVector3D(0, 0, 0);
}
QTextStream fileStream(&objFile);
while (!fileStream.atEnd()) {
QString line = fileStream.readLine().trimmed();
if (line.isEmpty() || line.startsWith('#')) continue;
QVector<QString> lineParts = splitStr(line);
if (lineParts.isEmpty()) continue;
// 只解析顶点位置（"v x y z"格式）
if (lineParts[0] == "v" && lineParts.size() >= 4) {
vertices.append(QVector3D(
lineParts[1].toFloat(),
lineParts[2].toFloat(),
lineParts[3].toFloat()
));
}
}
objFile.close();
return calculateBoundingBoxCenter(vertices);
}
/**
* @brief 打印器件的世界坐标信息
* 输出器件的外层位置、几何中心及实际世界中心
* @param deviceName 器件名称
*/
void ObjLoader::printDeviceWorldPos(const QString &deviceName)
{
Device *device = getDevice(deviceName);
if (!device || !device->isInitialized) {
qCritical() << "[定位错误] 设备'" << deviceName << "'未找到或未初始化";
return;
}
// 计算滚筒几何中心的世界坐标（外层位置 + 局部中心）
QVector3D deviceCenterWorld = device->worldPosition + device->modelCenter;
if(EnDebug) qDebug() << "=== 设备'" << deviceName << "'位置信息 ===";
if(EnDebug) qDebug() << "外层实体世界坐标（位置基准）：" << device->worldPosition;
if(EnDebug) qDebug() << "几何中心（局部坐标）：" << device->modelCenter;
if(EnDebug) qDebug() << "几何中心世界坐标（实际本体位置）：" << deviceCenterWorld;
if(EnDebug) qDebug() << "当前旋转角度：" << device->currentRotation;
if(EnDebug) qDebug() << "缩放比例：" << device->scale;
}
/**
* @brief 更新整体模型（重建实体）
* 清除旧的整体模型实体，创建新的实体、变换和材质
*/
void ObjLoader::updateWholeModel()
{
delete m_wholeModelEntity;
m_wholeModelEntity = nullptr;
m_wholeModelMesh = nullptr;
m_wholeModelTrans = nullptr;
m_wholeModelEntity = new Qt3DCore::QEntity(m_rootEntity);
// 添加模型变换组件（预中心化）
m_wholeModelTrans = new Qt3DCore::QTransform();
m_wholeModelTrans->setTranslation(-m_wholeModelCenter);
m_wholeModelEntity->addComponent(m_wholeModelTrans);
// 添加网格组件
m_wholeModelMesh = new Qt3DRender::QMesh();
m_wholeModelEntity->addComponent(m_wholeModelMesh);
// 添加材质
Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial();
material->setDiffuse(QColor(0xbeb32b)); // 金色
material->setSpecular(QColor(255, 255, 255));
material->setShininess(60.0f);
m_wholeModelEntity->addComponent(material);
}
/**
* @brief 摇臂围绕自身局部原点旋转，带动子设备
* 首次调用记录初始状态，0°时复位，其他角度计算旋转矩阵并应用
* @param deviceName 摇臂名称
* @param targetZAngle 目标Z轴角度（度）
*/
void ObjLoader::rotateArmToAbsoluteZAngle(const QString &deviceName, float targetZAngle)
{
Device *armDevice = getDevice(deviceName);
if (!armDevice || !armDevice->isInitialized) {
m_lastError = deviceName + " ->设备不存在或未初始化: " + deviceName;
qCritical() << "[错误]" << m_lastError;
return;
}
/* 1. 首次调用时记录初始状态（只需一次） */
if (armDevice->initialRotation == QVector3D()) {
armDevice->initialRotation = QVector3D(0, 0, 0);
armDevice->initialWorldPosition = armDevice->worldPosition;
armDevice->initialTransformMatrix = armDevice->transform->matrix();
armDevice->initialModelTransformMatrix = armDevice->modelTransform->matrix();
}
/* 2. 0°复位 */
if (qFuzzyCompare(targetZAngle, 0.0f)) {
armDevice->worldPosition = armDevice->initialWorldPosition;
armDevice->currentRotation = armDevice->initialRotation;
armDevice->transform->setMatrix(armDevice->initialTransformMatrix);
armDevice->modelTransform->setMatrix(armDevice->initialModelTransformMatrix);
for (Device *child : getAllChildren(armDevice)) {
child->worldPosition = child->initialWorldPosition;
child->transform->setMatrix(child->initialTransformMatrix);
child->modelTransform->setMatrix(child->initialModelTransformMatrix);
}
return;
}
/* 3. 计算旋转矩阵：绕摇臂自身局部原点（0,0,0） */
QMatrix4x4 rotMat;
rotMat.setToIdentity();
rotMat.rotate(targetZAngle, 0, 0, 1); // 仅 Z 轴
/* 4. 应用旋转到外层 transform（平移+旋转） */
armDevice->currentRotation.setZ(targetZAngle);
armDevice->transform->setRotationZ(targetZAngle); // 外层只转 Z
// 保持原平移不变
armDevice->transform->setTranslation(armDevice->worldPosition);
/* 5. 同步子设备：继承父旋转，更新世界坐标记录 */
for (Device *child : getAllChildren(armDevice)) {
// 子设备挂在 armDevice->entity 下，自动继承旋转
QMatrix4x4 worldMat = child->transform->matrix(); // 局部→世界矩阵
child->worldPosition = worldMat.column(3).toVector3D();
}
}
/**
* @brief 摇臂围绕自身局部原点绕X轴旋转，带动子设备
* 首次调用记录初始状态，0°时复位，其他角度计算旋转矩阵并应用
* @param deviceName 摇臂名称
* @param targetXAngle 目标X轴角度（度）
*/
void ObjLoader::rotateArmToAbsoluteXAngle(const QString &deviceName, float targetXAngle)
{
Device *armDevice = getDevice(deviceName);
if (!armDevice || !armDevice->isInitialized) {
m_lastError = "摇臂设备不存在或未初始化: " + deviceName;
qCritical() << "[错误]" << m_lastError;
return;
}
/* 1. 首次调用时记录初始状态（只需一次） */
if (armDevice->initialRotation == QVector3D()) {
armDevice->initialRotation = QVector3D(0, 0, 0);
armDevice->initialWorldPosition = armDevice->worldPosition;
armDevice->initialTransformMatrix = armDevice->transform->matrix();
armDevice->initialModelTransformMatrix = armDevice->modelTransform->matrix();
}
/* 2. 0°复位 */
if (qFuzzyCompare(targetXAngle, 0.0f)) {
armDevice->worldPosition = armDevice->initialWorldPosition;
armDevice->currentRotation = armDevice->initialRotation;
armDevice->transform->setMatrix(armDevice->initialTransformMatrix);
armDevice->modelTransform->setMatrix(armDevice->initialModelTransformMatrix);
for (Device *child : getAllChildren(armDevice)) {
child->worldPosition = child->initialWorldPosition;
child->transform->setMatrix(child->initialTransformMatrix);
child->modelTransform->setMatrix(child->initialModelTransformMatrix);
}
return;
}
/* 3. 计算旋转矩阵：绕摇臂自身局部原点（0,0,0）的X轴 */
QMatrix4x4 rotMat;
rotMat.setToIdentity();
rotMat.rotate(targetXAngle, 1, 0, 0); // 仅 X 轴
/* 4. 应用旋转到外层 transform（平移+旋转） */
armDevice->currentRotation.setX(targetXAngle);
armDevice->transform->setRotationX(targetXAngle); // 外层只转 X
// 保持原平移不变
armDevice->transform->setTranslation(armDevice->worldPosition);
/* 5. 同步子设备：继承父旋转，更新世界坐标记录 */
for (Device *child : getAllChildren(armDevice)) {
// 子设备挂在 armDevice->entity 下，自动继承旋转
QMatrix4x4 worldMat = child->transform->matrix(); // 局部→世界矩阵
child->worldPosition = worldMat.column(3).toVector3D();
}
}
/**
* @brief 摇臂围绕自身局部原点绕Y轴旋转，带动子设备
* 首次调用记录初始状态，0°时复位，其他角度计算旋转矩阵并应用
* @param deviceName 摇臂名称
* @param targetYAngle 目标Y轴角度（度）
*/
void ObjLoader::rotateArmToAbsoluteYAngle(const QString &deviceName, float targetYAngle)
{
Device *armDevice = getDevice(deviceName);
if (!armDevice || !armDevice->isInitialized) {
m_lastError = "摇臂设备不存在或未初始化: " + deviceName;
qCritical() << "[错误]" << m_lastError;
return;
}
/* 1. 首次调用时记录初始状态（只需一次） */
if (armDevice->initialRotation == QVector3D()) {
armDevice->initialRotation = QVector3D(0, 0, 0);
armDevice->initialWorldPosition = armDevice->worldPosition;
armDevice->initialTransformMatrix = armDevice->transform->matrix();
armDevice->initialModelTransformMatrix = armDevice->modelTransform->matrix();
}
/* 2. 0°复位 */
if (qFuzzyCompare(targetYAngle, 0.0f)) {
armDevice->worldPosition = armDevice->initialWorldPosition;
armDevice->currentRotation = armDevice->initialRotation;
armDevice->transform->setMatrix(armDevice->initialTransformMatrix);
armDevice->modelTransform->setMatrix(armDevice->initialModelTransformMatrix);
for (Device *child : getAllChildren(armDevice)) {
child->worldPosition = child->initialWorldPosition;
child->transform->setMatrix(child->initialTransformMatrix);
child->modelTransform->setMatrix(child->initialModelTransformMatrix);
}
return;
}
/* 3. 计算旋转矩阵：绕摇臂自身局部原点（0,0,0）的Y轴 */
QMatrix4x4 rotMat;
rotMat.setToIdentity();
rotMat.rotate(targetYAngle, 0, 1, 0); // 仅 Y 轴
/* 4. 应用旋转到外层 transform（平移+旋转） */
armDevice->currentRotation.setY(targetYAngle);
armDevice->transform->setRotationY(targetYAngle); // 外层只转 Y
// 保持原平移不变
armDevice->transform->setTranslation(armDevice->worldPosition);
/* 5. 同步子设备：继承父旋转，更新世界坐标记录 */
for (Device *child : getAllChildren(armDevice)) {
// 子设备挂在 armDevice->entity 下，自动继承旋转
QMatrix4x4 worldMat = child->transform->matrix(); // 局部→世界矩阵
child->worldPosition = worldMat.column(3).toVector3D();
}
}
/**
* @brief 调整子器件相对父器件的偏移量
* 用于更新子器件相对于其父器件的位置偏移，同时同步更新世界坐标
* @param childDeviceName 子器件名称
* @param newOffset 新的相对偏移量（父器件局部坐标系下）
*/
void ObjLoader::adjustChildDeviceOffset(const QString &childDeviceName, const QVector3D &newOffset)
{
// 获取子器件指针并验证有效性
Device *childDevice = getDevice(childDeviceName);
if (!childDevice || !childDevice->isInitialized || childDevice->parentDeviceName.isEmpty()) {
m_lastError = "子模型不存在或无父级: " + childDeviceName;
return;
}
// 更新相对偏移量并应用到变换组件
childDevice->offsetToParent = newOffset;
childDevice->transform->setTranslation(newOffset);
// 根据父器件位置更新子器件的世界坐标记录
Device *parentDevice = getDevice(childDevice->parentDeviceName);
if (parentDevice) {
childDevice->worldPosition = parentDevice->worldPosition + newOffset;
}
}
/**
* @brief 解析MTL材质文件
* 从MTL文件中提取材质属性（环境光、漫反射、高光等）并存储到材质映射表
* @param filePath MTL文件路径
* @return 解析成功返回true，失败返回false
*/
bool ObjLoader::parseMtlFile(const QString &filePath)
{
QFile mtlFile(filePath);
// 尝试打开MTL文件
if (!mtlFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
m_lastError = "无法打开MTL文件: " + filePath;
return false;
}
// 获取MTL文件所在目录（用于处理纹理路径）
QString baseDir = QFileInfo(filePath).path() + "/";
Material currentMaterial; // 当前正在解析的材质
bool hasMaterial = false; // 是否正在处理一个材质
QTextStream in(&mtlFile);
while (!in.atEnd()) {
QString line = in.readLine().trimmed();
// 跳过空行和注释行
if (line.isEmpty() || line.startsWith('#')) continue;
// 分割行内容（忽略空元素）
QVector<QString> parts = splitStr(line);
if (parts.isEmpty()) continue;
QString type = parts[0]; // 指令类型
// 处理新材质定义
if (type == "newmtl" && parts.size() >= 2) {
// 如果已有未保存的材质，先保存到映射表
if (hasMaterial) {
m_materials[currentMaterial.name] = currentMaterial;
}
// 初始化新材质
currentMaterial = Material();
currentMaterial.name = parts[1];
hasMaterial = true;
}
// 处理环境光颜色(Ka)
else if (type == "Ka" && parts.size() >= 4) {
currentMaterial.ambient = QColor::fromRgbF(
parts[1].toFloat(), parts[2].toFloat(), parts[3].toFloat());
}
// 处理漫反射颜色(Kd)
else if (type == "Kd" && parts.size() >= 4) {
currentMaterial.diffuse = QColor::fromRgbF(
parts[1].toFloat(), parts[2].toFloat(), parts[3].toFloat());
}
// 处理高光颜色(Ks)
else if (type == "Ks" && parts.size() >= 4) {
currentMaterial.specular = QColor::fromRgbF(
parts[1].toFloat(), parts[2].toFloat(), parts[3].toFloat());
}
// 处理高光光泽度(Ns)
else if (type == "Ns" && parts.size() >= 2) {
currentMaterial.shininess = parts[1].toFloat();
}
// 处理漫反射纹理(map_Kd)
else if (type == "map_Kd" && parts.size() >= 2) {
currentMaterial.diffuseMap = baseDir + parts[1];
}
// 处理透明度(d)
else if (type == "d" && parts.size() >= 2) {
currentMaterial.opacity = parts[1].toFloat(); // 读取透明度值（0.0~1.0）
}
}
// 保存最后一个材质
if (hasMaterial) {
m_materials[currentMaterial.name] = currentMaterial;
}
mtlFile.close();
return true;
}
/**
* @brief 递归获取指定父器件的所有子器件（包括孙子辈）
* 用于获取器件的完整层级结构，支持多层级嵌套
* @param parentDevice 父器件指针
* @return 所有子器件（含嵌套子器件）的指针列表
*/
QList<Device*> ObjLoader::getAllChildren(Device *parentDevice)
{
QList<Device*> children;
if (!parentDevice) return children;
// 遍历所有器件查找直接子器件
for (auto it = m_deviceMap.begin(); it != m_deviceMap.end(); ++it) {
Device &device = it.value();
if (device.parentDeviceName == parentDevice->name && device.isInitialized) {
children.append(&device);
// 递归获取当前子器件的子器件（孙子辈）
QList<Device*> grandChildren = getAllChildren(&device);
children << grandChildren;
}
}
return children;
}
/**
* @brief 计算顶点集合的包围盒中心
* 通过找出X、Y、Z三个轴上的最小值和最大值，计算包围盒的几何中心
* @param vertices 顶点坐标列表
* @return 包围盒中心坐标（局部坐标系）
*/
QVector3D ObjLoader::calculateBoundingBoxCenter(const QVector<QVector3D>& vertices)
{
if (vertices.isEmpty()) return QVector3D(0, 0, 0);
// 初始化最小/最大值为第一个顶点的坐标
float minX = vertices[0].x(), maxX = vertices[0].x();
float minY = vertices[0].y(), maxY = vertices[0].y();
float minZ = vertices[0].z(), maxZ = vertices[0].z();
// 遍历所有顶点，更新最小/最大值
for (const auto& v : vertices) {
minX = qMin(minX, v.x());
maxX = qMax(maxX, v.x());
minY = qMin(minY, v.y());
maxY = qMax(maxY, v.y());
minZ = qMin(minZ, v.z());
maxZ = qMax(maxZ, v.z());
}
// 计算并返回包围盒中心点坐标
return QVector3D(
(minX + maxX) / 2.0f,
(minY + maxY) / 2.0f,
(minZ + maxZ) / 2.0f
);
}
/**
* @brief 将摇臂的局部坐标系原点移动到指定世界坐标
* 调整摇臂的外层和内层变换，使其实体原点与目标世界坐标对齐，同时保持子器件相对位置
* @param deviceName 摇臂器件名称
* @param targetWorldPos 目标世界坐标（新的局部原点位置）
*/
void ObjLoader::moveArmLocalOriginTo(const QString &deviceName, const QVector3D &targetWorldPos)
{
// 1. 获取摇臂设备并验证
Device *armDevice = getDevice(deviceName);
if (!armDevice || !armDevice->isInitialized) {
m_lastError = "摇臂设备不存在或未初始化: " + deviceName;
qCritical() << "[错误]" << m_lastError;
return;
}
// 2. 记录当前世界位置（用于计算偏移）
QVector3D currentWorldPos = armDevice->worldPosition;
// 3. 计算原点偏移量：目标位置与当前位置的差值
QVector3D originOffset = targetWorldPos - currentWorldPos;
// 4. 调整外层变换：将实体原点移动到目标世界坐标
armDevice->transform->setTranslation(targetWorldPos);
armDevice->worldPosition = targetWorldPos;
// 5. 补偿内层变换：保持模型几何中心与局部原点的相对位置
// 原模型中心在局部坐标中为(modelCenter)，通过偏移抵消外层变换的影响
QVector3D newModelTranslation = armDevice->modelTransform->translation() - originOffset;
armDevice->modelTransform->setTranslation(newModelTranslation);
// 6. 更新初始状态：确保后续旋转/复位操作基于新原点
armDevice->initialWorldPosition = targetWorldPos;
armDevice->initialTransformMatrix = armDevice->transform->matrix();
armDevice->initialModelTransformMatrix = armDevice->modelTransform->matrix();
// 7. 同步更新所有子设备（如滚筒）的位置，保持相对偏移
QList<Device*> children = getAllChildren(armDevice);
for (Device* child : children) {
// 计算子设备相对摇臂原原点的偏移量
QVector3D childRelativeOffset = child->worldPosition - currentWorldPos;
// 基于新原点计算子设备新位置
child->worldPosition = targetWorldPos + childRelativeOffset;
child->transform->setTranslation(child->worldPosition);
// 更新子设备的初始状态
child->initialWorldPosition = child->worldPosition;
child->initialTransformMatrix = child->transform->matrix();
}
// 标记局部旋转中心为新原点
armDevice->localPivot = QVector3D(0,0,0);
if(EnDebug) qDebug() << "[坐标系移动完成] 摇臂" << deviceName
<< "局部原点已移动到世界坐标:" << targetWorldPos
<< "| 偏移补偿量:" << originOffset;
}
Reference in New Issue Copy Permalink