1501 lines
59 KiB
C++
1501 lines
59 KiB
C++
#include "document_window.h"
|
|
#include "about_widget.h"
|
|
#include "bone_manage_widget.h"
|
|
#include "cut_face_preview.h"
|
|
#include "document.h"
|
|
#include "document_saver.h"
|
|
#include "fbx_file.h"
|
|
#include "float_number_widget.h"
|
|
#include "flow_layout.h"
|
|
#include "glb_file.h"
|
|
#include "horizontal_line_widget.h"
|
|
#include "image_forever.h"
|
|
#include "log_browser.h"
|
|
#include "part_manage_widget.h"
|
|
#include "preferences.h"
|
|
#include "skeleton_graphics_widget.h"
|
|
#include "spinnable_toolbar_icon.h"
|
|
#include "theme.h"
|
|
#include "updates_check_widget.h"
|
|
#include "uv_map_generator.h"
|
|
#include "version.h"
|
|
#include <QApplication>
|
|
#include <QDesktopServices>
|
|
#include <QDir>
|
|
#include <QDockWidget>
|
|
#include <QFileDialog>
|
|
#include <QFileInfo>
|
|
#include <QFormLayout>
|
|
#include <QGraphicsOpacityEffect>
|
|
#include <QGridLayout>
|
|
#include <QHBoxLayout>
|
|
#include <QLabel>
|
|
#include <QMenuBar>
|
|
#include <QMessageBox>
|
|
#include <QMimeData>
|
|
#include <QPixmap>
|
|
#include <QPointer>
|
|
#include <QPushButton>
|
|
#include <QTabWidget>
|
|
#include <QTextBrowser>
|
|
#include <QTimer>
|
|
#include <QToolBar>
|
|
#include <QVBoxLayout>
|
|
#include <QWidgetAction>
|
|
#include <QtCore/qbuffer.h>
|
|
#include <dust3d/base/debug.h>
|
|
#include <dust3d/base/ds3_file.h>
|
|
#include <dust3d/base/snapshot.h>
|
|
#include <dust3d/base/snapshot_xml.h>
|
|
#include <map>
|
|
|
|
LogBrowser* g_logBrowser = nullptr;
|
|
std::map<DocumentWindow*, dust3d::Uuid> g_documentWindows;
|
|
QTextBrowser* g_acknowlegementsWidget = nullptr;
|
|
AboutWidget* g_aboutWidget = nullptr;
|
|
QTextBrowser* g_contributorsWidget = nullptr;
|
|
QTextBrowser* g_supportersWidget = nullptr;
|
|
UpdatesCheckWidget* g_updatesCheckWidget = nullptr;
|
|
|
|
void outputMessage(QtMsgType type, const QMessageLogContext& context, const QString& msg)
|
|
{
|
|
if (g_logBrowser)
|
|
g_logBrowser->outputMessage(type, msg, context.file, context.line);
|
|
}
|
|
|
|
void ensureFileExtension(QString* filename, const QString extension)
|
|
{
|
|
if (!filename->endsWith(extension)) {
|
|
filename->append(extension);
|
|
}
|
|
}
|
|
|
|
const std::map<DocumentWindow*, dust3d::Uuid>& DocumentWindow::documentWindows()
|
|
{
|
|
return g_documentWindows;
|
|
}
|
|
|
|
Document* DocumentWindow::document()
|
|
{
|
|
return m_document;
|
|
}
|
|
|
|
void DocumentWindow::showAcknowlegements()
|
|
{
|
|
if (!g_acknowlegementsWidget) {
|
|
g_acknowlegementsWidget = new QTextBrowser;
|
|
g_acknowlegementsWidget->setWindowTitle(applicationTitle(tr("Acknowlegements")));
|
|
g_acknowlegementsWidget->setMinimumSize(QSize(600, 300));
|
|
QFile file(":/ACKNOWLEDGEMENTS.html");
|
|
file.open(QFile::ReadOnly | QFile::Text);
|
|
QTextStream stream(&file);
|
|
g_acknowlegementsWidget->setHtml(stream.readAll());
|
|
}
|
|
g_acknowlegementsWidget->show();
|
|
g_acknowlegementsWidget->activateWindow();
|
|
g_acknowlegementsWidget->raise();
|
|
}
|
|
|
|
void DocumentWindow::showContributors()
|
|
{
|
|
if (!g_contributorsWidget) {
|
|
g_contributorsWidget = new QTextBrowser;
|
|
g_contributorsWidget->setWindowTitle(applicationTitle(tr("Contributors")));
|
|
g_contributorsWidget->setMinimumSize(QSize(600, 300));
|
|
QFile authors(":/AUTHORS");
|
|
authors.open(QFile::ReadOnly | QFile::Text);
|
|
QFile contributors(":/CONTRIBUTORS");
|
|
contributors.open(QFile::ReadOnly | QFile::Text);
|
|
g_contributorsWidget->setHtml("<h1>AUTHORS</h1><pre>" + authors.readAll() + "</pre><h1>CONTRIBUTORS</h1><pre>" + contributors.readAll() + "</pre>");
|
|
}
|
|
g_contributorsWidget->show();
|
|
g_contributorsWidget->activateWindow();
|
|
g_contributorsWidget->raise();
|
|
}
|
|
|
|
void DocumentWindow::showSupporters()
|
|
{
|
|
if (!g_supportersWidget) {
|
|
g_supportersWidget = new QTextBrowser;
|
|
g_supportersWidget->setWindowTitle(applicationTitle(tr("Supporters")));
|
|
g_supportersWidget->setMinimumSize(QSize(600, 300));
|
|
QFile supporters(":/SUPPORTERS");
|
|
supporters.open(QFile::ReadOnly | QFile::Text);
|
|
g_supportersWidget->setHtml("<h1>SUPPORTERS</h1><pre>" + supporters.readAll() + "</pre>");
|
|
}
|
|
g_supportersWidget->show();
|
|
g_supportersWidget->activateWindow();
|
|
g_supportersWidget->raise();
|
|
}
|
|
|
|
void DocumentWindow::showAbout()
|
|
{
|
|
if (!g_aboutWidget) {
|
|
g_aboutWidget = new AboutWidget;
|
|
}
|
|
g_aboutWidget->show();
|
|
g_aboutWidget->activateWindow();
|
|
g_aboutWidget->raise();
|
|
}
|
|
|
|
void DocumentWindow::checkForUpdates()
|
|
{
|
|
if (!g_updatesCheckWidget) {
|
|
g_updatesCheckWidget = new UpdatesCheckWidget;
|
|
}
|
|
g_updatesCheckWidget->check();
|
|
g_updatesCheckWidget->show();
|
|
g_updatesCheckWidget->activateWindow();
|
|
g_updatesCheckWidget->raise();
|
|
}
|
|
|
|
size_t DocumentWindow::total()
|
|
{
|
|
return g_documentWindows.size();
|
|
}
|
|
|
|
DocumentWindow::DocumentWindow()
|
|
{
|
|
if (!g_logBrowser) {
|
|
g_logBrowser = new LogBrowser;
|
|
qInstallMessageHandler(&outputMessage);
|
|
}
|
|
|
|
g_documentWindows.insert({ this, dust3d::Uuid::createUuid() });
|
|
|
|
m_document = new Document;
|
|
|
|
SkeletonGraphicsWidget* canvasGraphicsWidget = new SkeletonGraphicsWidget(m_document);
|
|
m_canvasGraphicsWidget = canvasGraphicsWidget;
|
|
|
|
QVBoxLayout* toolButtonLayout = new QVBoxLayout;
|
|
toolButtonLayout->setSpacing(0);
|
|
toolButtonLayout->setContentsMargins(5, 10, 4, 0);
|
|
|
|
ToolbarButton* addButton = new ToolbarButton(":/resources/toolbar_add.svg");
|
|
addButton->setToolTip(tr("Add node to canvas"));
|
|
|
|
ToolbarButton* selectButton = new ToolbarButton(":/resources/toolbar_pointer.svg");
|
|
selectButton->setToolTip(tr("Select node on canvas"));
|
|
|
|
m_xLockButton = new ToolbarButton();
|
|
m_xLockButton->setToolTip(tr("X axis locker"));
|
|
updateXlockButtonState();
|
|
|
|
m_yLockButton = new ToolbarButton();
|
|
m_yLockButton->setToolTip(tr("Y axis locker"));
|
|
updateYlockButtonState();
|
|
|
|
m_zLockButton = new ToolbarButton();
|
|
m_zLockButton->setToolTip(tr("Z axis locker"));
|
|
updateZlockButtonState();
|
|
|
|
m_radiusLockButton = new ToolbarButton();
|
|
m_radiusLockButton->setToolTip(tr("Node radius locker"));
|
|
updateRadiusLockButtonState();
|
|
|
|
m_inprogressIndicator = new SpinnableToolbarIcon();
|
|
updateInprogressIndicator();
|
|
|
|
connect(m_document, &Document::meshGenerating, this, &DocumentWindow::updateInprogressIndicator);
|
|
connect(m_document, &Document::resultMeshChanged, this, [=]() {
|
|
m_isLastMeshGenerationSucceed = m_document->isMeshGenerationSucceed();
|
|
updateInprogressIndicator();
|
|
});
|
|
connect(m_document, &Document::resultComponentPreviewMeshesChanged, this, &DocumentWindow::generateComponentPreviewImages);
|
|
connect(m_document, &Document::textureChanged, this, &DocumentWindow::generateComponentPreviewImages);
|
|
connect(m_document, &Document::postProcessing, this, &DocumentWindow::updateInprogressIndicator);
|
|
connect(m_document, &Document::textureGenerating, this, &DocumentWindow::updateInprogressIndicator);
|
|
connect(m_document, &Document::resultTextureChanged, this, &DocumentWindow::updateInprogressIndicator);
|
|
connect(m_document, &Document::postProcessedResultChanged, this, &DocumentWindow::updateInprogressIndicator);
|
|
connect(m_document, &Document::boneGenerating, this, &DocumentWindow::updateInprogressIndicator);
|
|
connect(m_document, &Document::resultBoneChanged, this, &DocumentWindow::updateInprogressIndicator);
|
|
connect(m_document, &Document::resultBonePreviewMeshesChanged, this, &DocumentWindow::generateBonePreviewImages);
|
|
|
|
toolButtonLayout->addWidget(addButton);
|
|
toolButtonLayout->addWidget(selectButton);
|
|
toolButtonLayout->addSpacing(20);
|
|
toolButtonLayout->addWidget(m_xLockButton);
|
|
toolButtonLayout->addWidget(m_yLockButton);
|
|
toolButtonLayout->addWidget(m_zLockButton);
|
|
toolButtonLayout->addWidget(m_radiusLockButton);
|
|
toolButtonLayout->addSpacing(20);
|
|
toolButtonLayout->addWidget(m_inprogressIndicator);
|
|
|
|
QLabel* verticalLogoLabel = new QLabel;
|
|
QImage verticalLogoImage;
|
|
verticalLogoImage.load(":/resources/dust3d-vertical.png");
|
|
verticalLogoLabel->setPixmap(QPixmap::fromImage(verticalLogoImage));
|
|
|
|
QHBoxLayout* logoLayout = new QHBoxLayout;
|
|
logoLayout->addWidget(verticalLogoLabel);
|
|
logoLayout->setContentsMargins(0, 0, 0, 0);
|
|
|
|
QVBoxLayout* mainLeftLayout = new QVBoxLayout;
|
|
mainLeftLayout->setSpacing(0);
|
|
mainLeftLayout->setContentsMargins(0, 0, 0, 0);
|
|
mainLeftLayout->addLayout(toolButtonLayout);
|
|
mainLeftLayout->addStretch();
|
|
mainLeftLayout->addLayout(logoLayout);
|
|
mainLeftLayout->addSpacing(10);
|
|
|
|
GraphicsContainerWidget* containerWidget = new GraphicsContainerWidget;
|
|
containerWidget->setGraphicsWidget(canvasGraphicsWidget);
|
|
QGridLayout* containerLayout = new QGridLayout;
|
|
containerLayout->setSpacing(0);
|
|
containerLayout->setContentsMargins(1, 0, 0, 0);
|
|
containerLayout->addWidget(canvasGraphicsWidget);
|
|
containerWidget->setLayout(containerLayout);
|
|
containerWidget->setMinimumSize(400, 400);
|
|
|
|
m_graphicsContainerWidget = containerWidget;
|
|
|
|
m_modelRenderWidget = new ModelWidget(containerWidget);
|
|
m_modelRenderWidget->setMoveAndZoomByWindow(false);
|
|
m_modelRenderWidget->move(0, 0);
|
|
m_modelRenderWidget->setAttribute(Qt::WA_TransparentForMouseEvents);
|
|
m_modelRenderWidget->toggleWireframe();
|
|
m_modelRenderWidget->disableCullFace();
|
|
m_modelRenderWidget->setEyePosition(QVector3D(0.0, 0.0, -4.0));
|
|
m_modelRenderWidget->setMoveToPosition(QVector3D(-0.5, -0.5, 0.0));
|
|
|
|
connect(containerWidget, &GraphicsContainerWidget::containerSizeChanged,
|
|
m_modelRenderWidget, &ModelWidget::canvasResized);
|
|
|
|
m_canvasGraphicsWidget->setModelWidget(m_modelRenderWidget);
|
|
containerWidget->setModelWidget(m_modelRenderWidget);
|
|
|
|
setTabPosition(Qt::RightDockWidgetArea, QTabWidget::East);
|
|
|
|
QDockWidget* partsDocker = new QDockWidget(tr("Parts"), this);
|
|
partsDocker->setAllowedAreas(Qt::RightDockWidgetArea);
|
|
m_partManageWidget = new PartManageWidget(m_document);
|
|
partsDocker->setWidget(m_partManageWidget);
|
|
addDockWidget(Qt::RightDockWidgetArea, partsDocker);
|
|
|
|
QDockWidget* bonesDocker = new QDockWidget(tr("Bones"), this);
|
|
m_boneManageWidget = new BoneManageWidget(m_document);
|
|
bonesDocker->setWidget(m_boneManageWidget);
|
|
bonesDocker->setAllowedAreas(Qt::RightDockWidgetArea);
|
|
|
|
connect(bonesDocker, &QDockWidget::visibilityChanged, this, [this](bool visible) {
|
|
if (this->m_showBodyBonePreview == visible)
|
|
return;
|
|
this->m_showBodyBonePreview = visible;
|
|
forceUpdateRenderModel();
|
|
});
|
|
|
|
tabifyDockWidget(partsDocker, bonesDocker);
|
|
|
|
partsDocker->raise();
|
|
|
|
QWidget* titleBarWidget = new QWidget;
|
|
titleBarWidget->setFixedHeight(1);
|
|
|
|
QHBoxLayout* titleBarLayout = new QHBoxLayout;
|
|
titleBarLayout->addStretch();
|
|
titleBarWidget->setLayout(titleBarLayout);
|
|
|
|
QVBoxLayout* canvasLayout = new QVBoxLayout;
|
|
canvasLayout->setSpacing(0);
|
|
canvasLayout->setContentsMargins(0, 0, 0, 0);
|
|
canvasLayout->addWidget(titleBarWidget);
|
|
canvasLayout->addWidget(containerWidget);
|
|
canvasLayout->setStretch(1, 1);
|
|
|
|
QHBoxLayout* mainLayout = new QHBoxLayout;
|
|
mainLayout->setSpacing(0);
|
|
mainLayout->setContentsMargins(0, 0, 0, 0);
|
|
mainLayout->addLayout(mainLeftLayout);
|
|
mainLayout->addLayout(canvasLayout);
|
|
mainLayout->addSpacing(3);
|
|
|
|
QWidget* centralWidget = new QWidget;
|
|
centralWidget->setLayout(mainLayout);
|
|
|
|
setCentralWidget(centralWidget);
|
|
setWindowTitle(APP_NAME);
|
|
|
|
m_fileMenu = menuBar()->addMenu(tr("&File"));
|
|
|
|
m_newWindowAction = new QAction(tr("New Window"), this);
|
|
connect(m_newWindowAction, &QAction::triggered, this, &DocumentWindow::newWindow, Qt::QueuedConnection);
|
|
m_fileMenu->addAction(m_newWindowAction);
|
|
|
|
m_newDocumentAction = m_fileMenu->addAction(tr("&New"),
|
|
this, &DocumentWindow::newDocument,
|
|
QKeySequence::New);
|
|
|
|
m_openAction = m_fileMenu->addAction(tr("&Open..."),
|
|
this, &DocumentWindow::open,
|
|
QKeySequence::Open);
|
|
|
|
m_openExampleMenu = new QMenu(tr("Open Example"));
|
|
std::vector<QString> exampleModels = {
|
|
"Addax",
|
|
"Banana",
|
|
"Bicycle",
|
|
"Dog",
|
|
"Meerkat",
|
|
"Mosquito",
|
|
"Screwdriver",
|
|
"Seagull"
|
|
};
|
|
for (const auto& model : exampleModels) {
|
|
QAction* openModelAction = new QAction(model, this);
|
|
connect(openModelAction, &QAction::triggered, this, [this, model]() {
|
|
openExample("model-" + model.toLower().replace(QChar(' '), QChar('-')) + ".ds3");
|
|
});
|
|
m_openExampleMenu->addAction(openModelAction);
|
|
}
|
|
|
|
m_fileMenu->addMenu(m_openExampleMenu);
|
|
|
|
m_saveAction = m_fileMenu->addAction(tr("&Save"),
|
|
this, &DocumentWindow::save,
|
|
QKeySequence::Save);
|
|
|
|
m_saveAsAction = new QAction(tr("Save As..."), this);
|
|
connect(m_saveAsAction, &QAction::triggered, this, &DocumentWindow::saveAs, Qt::QueuedConnection);
|
|
m_fileMenu->addAction(m_saveAsAction);
|
|
|
|
m_saveAllAction = new QAction(tr("Save All"), this);
|
|
connect(m_saveAllAction, &QAction::triggered, this, &DocumentWindow::saveAll, Qt::QueuedConnection);
|
|
m_fileMenu->addAction(m_saveAllAction);
|
|
|
|
m_fileMenu->addSeparator();
|
|
|
|
m_exportAsObjAction = new QAction(tr("Export as OBJ..."), this);
|
|
connect(m_exportAsObjAction, &QAction::triggered, this, &DocumentWindow::exportObjResult, Qt::QueuedConnection);
|
|
m_fileMenu->addAction(m_exportAsObjAction);
|
|
|
|
m_exportAsGlbAction = new QAction(tr("Export as GLB..."), this);
|
|
connect(m_exportAsGlbAction, &QAction::triggered, this, &DocumentWindow::exportGlbResult, Qt::QueuedConnection);
|
|
m_fileMenu->addAction(m_exportAsGlbAction);
|
|
|
|
m_exportAsFbxAction = new QAction(tr("Export as FBX..."), this);
|
|
connect(m_exportAsFbxAction, &QAction::triggered, this, &DocumentWindow::exportFbxResult, Qt::QueuedConnection);
|
|
m_fileMenu->addAction(m_exportAsFbxAction);
|
|
|
|
m_fileMenu->addSeparator();
|
|
|
|
m_changeTurnaroundAction = new QAction(tr("Change Reference Sheet..."), this);
|
|
connect(m_changeTurnaroundAction, &QAction::triggered, this, &DocumentWindow::changeTurnaround, Qt::QueuedConnection);
|
|
m_fileMenu->addAction(m_changeTurnaroundAction);
|
|
|
|
m_fileMenu->addSeparator();
|
|
|
|
for (int i = 0; i < Preferences::instance().maxRecentFiles(); ++i) {
|
|
QAction* action = new QAction(this);
|
|
action->setVisible(false);
|
|
connect(action, &QAction::triggered, this, &DocumentWindow::openRecentFile, Qt::QueuedConnection);
|
|
m_recentFileActions.push_back(action);
|
|
m_fileMenu->addAction(action);
|
|
}
|
|
m_recentFileSeparatorAction = m_fileMenu->addSeparator();
|
|
m_recentFileSeparatorAction->setVisible(false);
|
|
updateRecentFileActions();
|
|
|
|
m_quitAction = m_fileMenu->addAction(tr("&Quit"),
|
|
this, &DocumentWindow::close,
|
|
QKeySequence::Quit);
|
|
|
|
connect(m_fileMenu, &QMenu::aboutToShow, [=]() {
|
|
m_exportAsObjAction->setEnabled(m_canvasGraphicsWidget->hasItems());
|
|
m_exportAsGlbAction->setEnabled(m_canvasGraphicsWidget->hasItems() && m_document->isExportReady());
|
|
m_exportAsFbxAction->setEnabled(m_canvasGraphicsWidget->hasItems() && m_document->isExportReady());
|
|
});
|
|
|
|
m_viewMenu = menuBar()->addMenu(tr("&View"));
|
|
|
|
m_toggleWireframeAction = new QAction(tr("Toggle Wireframe"), this);
|
|
connect(m_toggleWireframeAction, &QAction::triggered, [=]() {
|
|
m_modelRenderWidget->toggleWireframe();
|
|
});
|
|
m_viewMenu->addAction(m_toggleWireframeAction);
|
|
|
|
m_toggleRotationAction = new QAction(tr("Toggle Rotation"), this);
|
|
connect(m_toggleRotationAction, &QAction::triggered, [=]() {
|
|
m_modelRenderWidget->toggleRotation();
|
|
});
|
|
m_viewMenu->addAction(m_toggleRotationAction);
|
|
|
|
m_toggleColorAction = new QAction(tr("Toggle Color"), this);
|
|
connect(m_toggleColorAction, &QAction::triggered, this, &DocumentWindow::toggleRenderColor);
|
|
m_viewMenu->addAction(m_toggleColorAction);
|
|
|
|
m_windowMenu = menuBar()->addMenu(tr("&Window"));
|
|
|
|
m_showPartsListAction = new QAction(tr("Parts"), this);
|
|
connect(m_showPartsListAction, &QAction::triggered, [=]() {
|
|
partsDocker->show();
|
|
partsDocker->raise();
|
|
});
|
|
m_windowMenu->addAction(m_showPartsListAction);
|
|
|
|
m_showBonesListAction = new QAction(tr("Bones"), this);
|
|
connect(m_showBonesListAction, &QAction::triggered, [=]() {
|
|
bonesDocker->show();
|
|
bonesDocker->raise();
|
|
});
|
|
m_windowMenu->addAction(m_showBonesListAction);
|
|
|
|
QMenu* dialogsMenu = m_windowMenu->addMenu(tr("Dialogs"));
|
|
connect(dialogsMenu, &QMenu::aboutToShow, [=]() {
|
|
dialogsMenu->clear();
|
|
if (this->m_dialogs.empty()) {
|
|
QAction* action = dialogsMenu->addAction(tr("None"));
|
|
action->setEnabled(false);
|
|
return;
|
|
}
|
|
for (const auto& dialog : this->m_dialogs) {
|
|
QAction* action = dialogsMenu->addAction(dialog->windowTitle());
|
|
connect(action, &QAction::triggered, [=]() {
|
|
dialog->show();
|
|
dialog->raise();
|
|
});
|
|
}
|
|
});
|
|
|
|
m_showDebugDialogAction = new QAction(tr("Debug"), this);
|
|
connect(m_showDebugDialogAction, &QAction::triggered, g_logBrowser, &LogBrowser::showDialog);
|
|
m_windowMenu->addAction(m_showDebugDialogAction);
|
|
|
|
m_helpMenu = menuBar()->addMenu(tr("&Help"));
|
|
|
|
m_gotoHomepageAction = new QAction(tr("Dust3D Homepage"), this);
|
|
connect(m_gotoHomepageAction, &QAction::triggered, this, &DocumentWindow::gotoHomepage);
|
|
m_helpMenu->addAction(m_gotoHomepageAction);
|
|
|
|
m_viewSourceAction = new QAction(tr("Source Code"), this);
|
|
connect(m_viewSourceAction, &QAction::triggered, this, &DocumentWindow::viewSource);
|
|
m_helpMenu->addAction(m_viewSourceAction);
|
|
|
|
m_checkForUpdatesAction = new QAction(tr("Check for Updates..."), this);
|
|
connect(m_checkForUpdatesAction, &QAction::triggered, this, &DocumentWindow::checkForUpdates);
|
|
m_helpMenu->addAction(m_checkForUpdatesAction);
|
|
|
|
m_helpMenu->addSeparator();
|
|
|
|
m_seeReferenceGuideAction = new QAction(tr("Reference Guide"), this);
|
|
connect(m_seeReferenceGuideAction, &QAction::triggered, this, &DocumentWindow::seeReferenceGuide);
|
|
m_helpMenu->addAction(m_seeReferenceGuideAction);
|
|
|
|
m_helpMenu->addSeparator();
|
|
|
|
m_aboutAction = new QAction(tr("About"), this);
|
|
connect(m_aboutAction, &QAction::triggered, this, &DocumentWindow::about);
|
|
m_helpMenu->addAction(m_aboutAction);
|
|
|
|
m_reportIssuesAction = new QAction(tr("Report Issues"), this);
|
|
connect(m_reportIssuesAction, &QAction::triggered, this, &DocumentWindow::reportIssues);
|
|
m_helpMenu->addAction(m_reportIssuesAction);
|
|
|
|
m_helpMenu->addSeparator();
|
|
|
|
m_seeContributorsAction = new QAction(tr("Contributors"), this);
|
|
connect(m_seeContributorsAction, &QAction::triggered, this, &DocumentWindow::seeContributors);
|
|
m_helpMenu->addAction(m_seeContributorsAction);
|
|
|
|
m_seeSupportersAction = new QAction(tr("Supporters"), this);
|
|
connect(m_seeSupportersAction, &QAction::triggered, this, &DocumentWindow::seeSupporters);
|
|
m_helpMenu->addAction(m_seeSupportersAction);
|
|
|
|
m_seeAcknowlegementsAction = new QAction(tr("Acknowlegements"), this);
|
|
connect(m_seeAcknowlegementsAction, &QAction::triggered, this, &DocumentWindow::seeAcknowlegements);
|
|
m_helpMenu->addAction(m_seeAcknowlegementsAction);
|
|
|
|
connect(containerWidget, &GraphicsContainerWidget::containerSizeChanged,
|
|
canvasGraphicsWidget, &SkeletonGraphicsWidget::canvasResized);
|
|
|
|
connect(m_document, &Document::turnaroundChanged,
|
|
canvasGraphicsWidget, &SkeletonGraphicsWidget::turnaroundChanged);
|
|
|
|
connect(addButton, &QPushButton::clicked, [=]() {
|
|
m_document->setEditMode(Document::EditMode::Add);
|
|
});
|
|
|
|
connect(selectButton, &QPushButton::clicked, [=]() {
|
|
m_document->setEditMode(Document::EditMode::Select);
|
|
});
|
|
|
|
connect(m_xLockButton, &QPushButton::clicked, [=]() {
|
|
m_document->setXlockState(!m_document->xlocked);
|
|
});
|
|
connect(m_yLockButton, &QPushButton::clicked, [=]() {
|
|
m_document->setYlockState(!m_document->ylocked);
|
|
});
|
|
connect(m_zLockButton, &QPushButton::clicked, [=]() {
|
|
m_document->setZlockState(!m_document->zlocked);
|
|
});
|
|
connect(m_radiusLockButton, &QPushButton::clicked, [=]() {
|
|
m_document->setRadiusLockState(!m_document->radiusLocked);
|
|
});
|
|
|
|
m_partListDockerVisibleSwitchConnection = connect(m_document, &Document::skeletonChanged, [=]() {
|
|
if (m_canvasGraphicsWidget->hasItems()) {
|
|
if (partsDocker->isHidden())
|
|
partsDocker->show();
|
|
disconnect(m_partListDockerVisibleSwitchConnection);
|
|
}
|
|
});
|
|
|
|
connect(m_document, &Document::editModeChanged, canvasGraphicsWidget, &SkeletonGraphicsWidget::editModeChanged);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::shortcutToggleWireframe, [=]() {
|
|
m_modelRenderWidget->toggleWireframe();
|
|
});
|
|
|
|
//connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::shortcutToggleFlatShading, [=]() {
|
|
// Preferences::instance().setFlatShading(!Preferences::instance().flatShading());
|
|
//});
|
|
|
|
//connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::shortcutToggleRotation, this, &DocumentWindow::toggleRotation);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::zoomRenderedModelBy, m_modelRenderWidget, &ModelWidget::zoom);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::addNode, m_document, &Document::addNode);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::scaleNodeByAddRadius, m_document, &Document::scaleNodeByAddRadius);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::moveNodeBy, m_document, &Document::moveNodeBy);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setNodeBoneJointState, m_document, &Document::setNodeBoneJointState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setNodeOrigin, m_document, &Document::setNodeOrigin);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::removeNode, m_document, &Document::removeNode);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::removePart, m_document, &Document::removePart);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setEditMode, m_document, &Document::setEditMode);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::removeEdge, m_document, &Document::removeEdge);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::addEdge, m_document, &Document::addEdge);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::groupOperationAdded, m_document, &Document::saveSnapshot);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::undo, m_document, &Document::undo);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::redo, m_document, &Document::redo);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::paste, m_document, &Document::paste);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::batchChangeBegin, m_document, &Document::batchChangeBegin);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::batchChangeEnd, m_document, &Document::batchChangeEnd);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::breakEdge, m_document, &Document::breakEdge);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::reduceNode, m_document, &Document::reduceNode);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::reverseEdge, m_document, &Document::reverseEdge);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::moveOriginBy, m_document, &Document::moveOriginBy);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::partChecked, m_document, &Document::partChecked);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::partUnchecked, m_document, &Document::partUnchecked);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::switchNodeXZ, m_document, &Document::switchNodeXZ);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartLockState, m_document, &Document::setPartLockState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartVisibleState, m_document, &Document::setPartVisibleState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartSubdivState, m_document, &Document::setPartSubdivState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartChamferState, m_document, &Document::setPartChamferState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartColorState, m_document, &Document::setPartColorState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartDisableState, m_document, &Document::setPartDisableState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartXmirrorState, m_document, &Document::setPartXmirrorState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartRoundState, m_document, &Document::setPartRoundState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setPartWrapState, m_document, &Document::setPartCutRotation);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::addNodesToBone, m_document, &Document::addNodesToBone);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::removeNodesFromBone, m_document, &Document::removeNodesFromBone);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::nodePicked, m_document, &Document::pickBoneNode);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setXlockState, m_document, &Document::setXlockState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setYlockState, m_document, &Document::setYlockState);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::setZlockState, m_document, &Document::setZlockState);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::enableAllPositionRelatedLocks, m_document, &Document::enableAllPositionRelatedLocks);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::disableAllPositionRelatedLocks, m_document, &Document::disableAllPositionRelatedLocks);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::changeTurnaround, this, &DocumentWindow::changeTurnaround);
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::open, this, &DocumentWindow::open);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::showOrHideAllComponents, m_document, &Document::showOrHideAllComponents);
|
|
|
|
connect(m_document, &Document::nodeAdded, canvasGraphicsWidget, &SkeletonGraphicsWidget::nodeAdded);
|
|
connect(m_document, &Document::nodeRemoved, canvasGraphicsWidget, &SkeletonGraphicsWidget::nodeRemoved);
|
|
connect(m_document, &Document::edgeAdded, canvasGraphicsWidget, &SkeletonGraphicsWidget::edgeAdded);
|
|
connect(m_document, &Document::edgeRemoved, canvasGraphicsWidget, &SkeletonGraphicsWidget::edgeRemoved);
|
|
connect(m_document, &Document::nodeRadiusChanged, canvasGraphicsWidget, &SkeletonGraphicsWidget::nodeRadiusChanged);
|
|
connect(m_document, &Document::nodeBoneJointStateChanged, canvasGraphicsWidget, &SkeletonGraphicsWidget::nodeBoneJointStateChanged);
|
|
connect(m_document, &Document::nodeOriginChanged, canvasGraphicsWidget, &SkeletonGraphicsWidget::nodeOriginChanged);
|
|
connect(m_document, &Document::edgeReversed, canvasGraphicsWidget, &SkeletonGraphicsWidget::edgeReversed);
|
|
connect(m_document, &Document::partVisibleStateChanged, canvasGraphicsWidget, &SkeletonGraphicsWidget::partVisibleStateChanged);
|
|
connect(m_document, &Document::partDisableStateChanged, canvasGraphicsWidget, &SkeletonGraphicsWidget::partVisibleStateChanged);
|
|
connect(m_document, &Document::cleanup, canvasGraphicsWidget, &SkeletonGraphicsWidget::removeAllContent);
|
|
connect(m_document, &Document::originChanged, canvasGraphicsWidget, &SkeletonGraphicsWidget::originChanged);
|
|
connect(m_document, &Document::checkPart, canvasGraphicsWidget, &SkeletonGraphicsWidget::selectPartAllById);
|
|
connect(m_document, &Document::enableBackgroundBlur, canvasGraphicsWidget, &SkeletonGraphicsWidget::enableBackgroundBlur);
|
|
connect(m_document, &Document::disableBackgroundBlur, canvasGraphicsWidget, &SkeletonGraphicsWidget::disableBackgroundBlur);
|
|
connect(m_document, &Document::uncheckAll, canvasGraphicsWidget, &SkeletonGraphicsWidget::unselectAll);
|
|
connect(m_document, &Document::checkNode, canvasGraphicsWidget, &SkeletonGraphicsWidget::addSelectNode);
|
|
connect(m_document, &Document::checkEdge, canvasGraphicsWidget, &SkeletonGraphicsWidget::addSelectEdge);
|
|
|
|
connect(m_partManageWidget, &PartManageWidget::unselectAllOnCanvas, canvasGraphicsWidget, &SkeletonGraphicsWidget::unselectAll);
|
|
connect(m_partManageWidget, &PartManageWidget::selectPartOnCanvas, canvasGraphicsWidget, &SkeletonGraphicsWidget::addPartToSelection);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::partComponentChecked, m_partManageWidget, &PartManageWidget::selectComponentByPartId);
|
|
|
|
connect(m_boneManageWidget, &BoneManageWidget::selectNodeOnCanvas, canvasGraphicsWidget, &SkeletonGraphicsWidget::addNodeToSelection);
|
|
|
|
connect(m_document, &Document::skeletonChanged, m_document, &Document::generateMesh);
|
|
connect(m_document, &Document::textureChanged, m_document, &Document::generateTexture);
|
|
connect(m_document, &Document::resultMeshChanged, m_document, &Document::postProcess);
|
|
connect(m_document, &Document::postProcessedResultChanged, m_document, &Document::generateTexture);
|
|
connect(m_document, &Document::rigChanged, m_document, &Document::generateBone);
|
|
connect(m_document, &Document::postProcessedResultChanged, m_document, &Document::generateBone);
|
|
connect(m_document, &Document::resultTextureChanged, this, &DocumentWindow::updateRenderModel);
|
|
|
|
connect(m_document, &Document::resultMeshChanged, this, &DocumentWindow::updateRenderModel);
|
|
connect(m_document, &Document::resultMeshChanged, this, &DocumentWindow::updateRenderWireframe);
|
|
|
|
connect(canvasGraphicsWidget, &SkeletonGraphicsWidget::cursorChanged, [=]() {
|
|
m_modelRenderWidget->setCursor(canvasGraphicsWidget->cursor());
|
|
containerWidget->setCursor(canvasGraphicsWidget->cursor());
|
|
});
|
|
|
|
connect(m_document, &Document::skeletonChanged, this, &DocumentWindow::documentChanged);
|
|
connect(m_document, &Document::textureChanged, this, &DocumentWindow::documentChanged);
|
|
connect(m_document, &Document::rigChanged, this, &DocumentWindow::documentChanged);
|
|
connect(m_document, &Document::turnaroundChanged, this, &DocumentWindow::documentChanged);
|
|
connect(m_document, &Document::optionsChanged, this, &DocumentWindow::documentChanged);
|
|
|
|
connect(m_modelRenderWidget, &ModelWidget::customContextMenuRequested, [=](const QPoint& pos) {
|
|
canvasGraphicsWidget->showContextMenu(canvasGraphicsWidget->mapFromGlobal(m_modelRenderWidget->mapToGlobal(pos)));
|
|
});
|
|
|
|
connect(m_document, &Document::xlockStateChanged, this, &DocumentWindow::updateXlockButtonState);
|
|
connect(m_document, &Document::ylockStateChanged, this, &DocumentWindow::updateYlockButtonState);
|
|
connect(m_document, &Document::zlockStateChanged, this, &DocumentWindow::updateZlockButtonState);
|
|
connect(m_document, &Document::radiusLockStateChanged, this, &DocumentWindow::updateRadiusLockButtonState);
|
|
|
|
initializeShortcuts();
|
|
|
|
connect(this, &DocumentWindow::initialized, m_document, &Document::uiReady);
|
|
|
|
QTimer* timer = new QTimer(this);
|
|
timer->setInterval(250);
|
|
connect(timer, &QTimer::timeout, [=] {
|
|
QWidget* focusedWidget = QApplication::focusWidget();
|
|
if (nullptr == focusedWidget && isActiveWindow())
|
|
canvasGraphicsWidget->setFocus();
|
|
});
|
|
timer->start();
|
|
}
|
|
|
|
void DocumentWindow::updateInprogressIndicator()
|
|
{
|
|
bool inprogress = m_document->isMeshGenerating() || m_document->isPostProcessing() || m_document->isTextureGenerating() || m_document->isBoneGenerating() || nullptr != m_componentPreviewImagesGenerator || nullptr != m_componentPreviewImagesDecorator;
|
|
if (inprogress == m_inprogressIndicator->isSpinning())
|
|
return;
|
|
m_inprogressIndicator->showSpinner(inprogress);
|
|
emit workingStatusChanged(inprogress);
|
|
}
|
|
|
|
void DocumentWindow::toggleRotation()
|
|
{
|
|
if (nullptr == m_canvasGraphicsWidget)
|
|
return;
|
|
m_canvasGraphicsWidget->setRotated(!m_canvasGraphicsWidget->rotated());
|
|
}
|
|
|
|
DocumentWindow* DocumentWindow::createDocumentWindow()
|
|
{
|
|
DocumentWindow* documentWindow = new DocumentWindow();
|
|
documentWindow->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
QSize size = Preferences::instance().documentWindowSize();
|
|
if (size.isValid()) {
|
|
documentWindow->resize(size);
|
|
documentWindow->show();
|
|
} else {
|
|
documentWindow->showMaximized();
|
|
}
|
|
|
|
return documentWindow;
|
|
}
|
|
|
|
void DocumentWindow::closeEvent(QCloseEvent* event)
|
|
{
|
|
if (!m_documentSaved) {
|
|
QMessageBox::StandardButton answer = QMessageBox::question(this,
|
|
APP_NAME,
|
|
tr("Do you really want to close while there are unsaved changes?"),
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (answer == QMessageBox::No) {
|
|
event->ignore();
|
|
return;
|
|
}
|
|
}
|
|
|
|
QSize saveSize;
|
|
if (!isMaximized())
|
|
saveSize = size();
|
|
Preferences::instance().setDocumentWindowSize(saveSize);
|
|
|
|
event->accept();
|
|
}
|
|
|
|
void DocumentWindow::setCurrentFilename(const QString& filename)
|
|
{
|
|
m_currentFilename = filename;
|
|
m_documentSaved = true;
|
|
updateTitle();
|
|
}
|
|
|
|
void DocumentWindow::updateTitle()
|
|
{
|
|
QString appName = APP_NAME;
|
|
QString appVer = APP_HUMAN_VER;
|
|
setWindowTitle(QString("%1 %2 %3%4").arg(appName).arg(appVer).arg(m_currentFilename).arg(m_documentSaved ? "" : "*"));
|
|
}
|
|
|
|
void DocumentWindow::documentChanged()
|
|
{
|
|
if (m_documentSaved) {
|
|
m_documentSaved = false;
|
|
updateTitle();
|
|
}
|
|
}
|
|
|
|
void DocumentWindow::newWindow()
|
|
{
|
|
DocumentWindow::createDocumentWindow();
|
|
}
|
|
|
|
void DocumentWindow::newDocument()
|
|
{
|
|
if (!m_documentSaved) {
|
|
QMessageBox::StandardButton answer = QMessageBox::question(this,
|
|
APP_NAME,
|
|
tr("Do you really want to create new document and lose the unsaved changes?"),
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (answer != QMessageBox::Yes)
|
|
return;
|
|
}
|
|
reset();
|
|
}
|
|
|
|
void DocumentWindow::reset()
|
|
{
|
|
m_document->clearHistories();
|
|
m_document->reset();
|
|
m_document->clearTurnaround();
|
|
m_document->saveSnapshot();
|
|
|
|
m_currentUpdatedMeshId = 0;
|
|
m_currentUpdatedWireframeId = 0;
|
|
}
|
|
|
|
void DocumentWindow::saveAs()
|
|
{
|
|
QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
|
|
tr("Dust3D Document (*.ds3)"));
|
|
if (filename.isEmpty()) {
|
|
return;
|
|
}
|
|
ensureFileExtension(&filename, ".ds3");
|
|
saveTo(filename);
|
|
}
|
|
|
|
void DocumentWindow::saveAll()
|
|
{
|
|
for (auto& it : g_documentWindows) {
|
|
it.first->save();
|
|
}
|
|
}
|
|
|
|
void DocumentWindow::viewSource()
|
|
{
|
|
QString url = APP_REPOSITORY_URL;
|
|
qDebug() << "viewSource:" << url;
|
|
QDesktopServices::openUrl(QUrl(url));
|
|
}
|
|
|
|
void DocumentWindow::gotoHomepage()
|
|
{
|
|
QString url = APP_HOMEPAGE_URL;
|
|
qDebug() << "gotoHomepage:" << url;
|
|
QDesktopServices::openUrl(QUrl(url));
|
|
}
|
|
|
|
void DocumentWindow::about()
|
|
{
|
|
DocumentWindow::showAbout();
|
|
}
|
|
|
|
void DocumentWindow::reportIssues()
|
|
{
|
|
QString url = APP_ISSUES_URL;
|
|
qDebug() << "reportIssues:" << url;
|
|
QDesktopServices::openUrl(QUrl(url));
|
|
}
|
|
|
|
void DocumentWindow::seeReferenceGuide()
|
|
{
|
|
QString url = APP_REFERENCE_GUIDE_URL;
|
|
qDebug() << "referenceGuide:" << url;
|
|
QDesktopServices::openUrl(QUrl(url));
|
|
}
|
|
|
|
void DocumentWindow::seeAcknowlegements()
|
|
{
|
|
DocumentWindow::showAcknowlegements();
|
|
}
|
|
|
|
void DocumentWindow::seeContributors()
|
|
{
|
|
DocumentWindow::showContributors();
|
|
}
|
|
|
|
void DocumentWindow::seeSupporters()
|
|
{
|
|
DocumentWindow::showSupporters();
|
|
}
|
|
|
|
DocumentWindow::~DocumentWindow()
|
|
{
|
|
emit uninialized();
|
|
g_documentWindows.erase(this);
|
|
delete m_document;
|
|
}
|
|
|
|
void DocumentWindow::showEvent(QShowEvent* event)
|
|
{
|
|
QMainWindow::showEvent(event);
|
|
if (m_firstShow) {
|
|
m_firstShow = false;
|
|
updateTitle();
|
|
m_document->saveSnapshot();
|
|
m_canvasGraphicsWidget->setFocus();
|
|
emit initialized();
|
|
}
|
|
}
|
|
|
|
void DocumentWindow::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
QMainWindow::mousePressEvent(event);
|
|
}
|
|
|
|
void DocumentWindow::changeTurnaround()
|
|
{
|
|
QString fileName = QFileDialog::getOpenFileName(this, QString(), QString(),
|
|
tr("Image Files (*.png *.jpg *.bmp)"))
|
|
.trimmed();
|
|
if (fileName.isEmpty())
|
|
return;
|
|
QImage image;
|
|
if (!image.load(fileName))
|
|
return;
|
|
m_document->updateTurnaround(image);
|
|
}
|
|
|
|
void DocumentWindow::save()
|
|
{
|
|
saveTo(m_currentFilename);
|
|
}
|
|
|
|
void DocumentWindow::saveTo(const QString& saveAsFilename)
|
|
{
|
|
QString filename = saveAsFilename;
|
|
|
|
if (filename.isEmpty()) {
|
|
filename = QFileDialog::getSaveFileName(this, QString(), QString(),
|
|
tr("Dust3D Document (*.ds3)"));
|
|
if (filename.isEmpty()) {
|
|
return;
|
|
}
|
|
ensureFileExtension(&filename, ".ds3");
|
|
}
|
|
|
|
QApplication::setOverrideCursor(Qt::WaitCursor);
|
|
dust3d::Snapshot snapshot;
|
|
m_document->toSnapshot(&snapshot);
|
|
if (DocumentSaver::save(&filename,
|
|
&snapshot,
|
|
(!m_document->turnaround.isNull() && m_document->turnaroundPngByteArray.size() > 0) ? &m_document->turnaroundPngByteArray : nullptr)) {
|
|
setCurrentFilename(filename);
|
|
}
|
|
QApplication::restoreOverrideCursor();
|
|
}
|
|
|
|
void DocumentWindow::openPathAs(const QString& path, const QString& asName)
|
|
{
|
|
QApplication::setOverrideCursor(Qt::WaitCursor);
|
|
|
|
reset();
|
|
|
|
QFile file(path);
|
|
file.open(QFile::ReadOnly);
|
|
QByteArray fileData = file.readAll();
|
|
|
|
dust3d::Ds3FileReader ds3Reader((const std::uint8_t*)fileData.data(), fileData.size());
|
|
for (int i = 0; i < (int)ds3Reader.items().size(); ++i) {
|
|
const dust3d::Ds3ReaderItem& item = ds3Reader.items()[i];
|
|
qDebug() << "[" << i << "]item.name:" << item.name << "item.type:" << item.type;
|
|
if (item.type == "asset") {
|
|
if (dust3d::String::startsWith(item.name, "images/")) {
|
|
std::string filename = dust3d::String::split(item.name, '/')[1];
|
|
std::string imageIdString = dust3d::String::split(filename, '.')[0];
|
|
dust3d::Uuid imageId = dust3d::Uuid(imageIdString);
|
|
if (!imageId.isNull()) {
|
|
std::vector<std::uint8_t> data;
|
|
ds3Reader.loadItem(item.name, &data);
|
|
QImage image = QImage::fromData(data.data(), (int)data.size(), "PNG");
|
|
(void)ImageForever::add(&image, imageId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < (int)ds3Reader.items().size(); ++i) {
|
|
const dust3d::Ds3ReaderItem& item = ds3Reader.items()[i];
|
|
if (item.type == "model") {
|
|
std::vector<std::uint8_t> data;
|
|
ds3Reader.loadItem(item.name, &data);
|
|
data.push_back('\0');
|
|
dust3d::Snapshot snapshot;
|
|
loadSnapshotFromXmlString(&snapshot, (char*)data.data());
|
|
m_document->fromSnapshot(snapshot);
|
|
m_document->saveSnapshot();
|
|
} else if (item.type == "asset") {
|
|
if (item.name == "canvas.png") {
|
|
std::vector<std::uint8_t> data;
|
|
ds3Reader.loadItem(item.name, &data);
|
|
m_document->updateTurnaround(QImage::fromData(data.data(), (int)data.size(), "PNG"));
|
|
}
|
|
}
|
|
}
|
|
|
|
QApplication::restoreOverrideCursor();
|
|
|
|
if (!asName.isEmpty()) {
|
|
Preferences::instance().setCurrentFile(path);
|
|
for (auto& it : g_documentWindows) {
|
|
it.first->updateRecentFileActions();
|
|
}
|
|
}
|
|
setCurrentFilename(asName);
|
|
}
|
|
|
|
void DocumentWindow::openExample(const QString& modelName)
|
|
{
|
|
if (!m_documentSaved) {
|
|
QMessageBox::StandardButton answer = QMessageBox::question(this,
|
|
APP_NAME,
|
|
tr("Do you really want to open example and lose the unsaved changes?"),
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (answer != QMessageBox::Yes)
|
|
return;
|
|
}
|
|
|
|
openPathAs(":/resources/" + modelName, "");
|
|
}
|
|
|
|
void DocumentWindow::open()
|
|
{
|
|
if (!m_documentSaved) {
|
|
QMessageBox::StandardButton answer = QMessageBox::question(this,
|
|
APP_NAME,
|
|
tr("Do you really want to open another file and lose the unsaved changes?"),
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (answer != QMessageBox::Yes)
|
|
return;
|
|
}
|
|
|
|
QString filename = QFileDialog::getOpenFileName(this, QString(), QString(),
|
|
tr("Dust3D Document (*.ds3)"));
|
|
if (filename.isEmpty())
|
|
return;
|
|
|
|
openPathAs(filename, filename);
|
|
}
|
|
|
|
void DocumentWindow::exportObjResult()
|
|
{
|
|
QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
|
|
tr("Wavefront (*.obj)"));
|
|
if (filename.isEmpty()) {
|
|
return;
|
|
}
|
|
ensureFileExtension(&filename, ".obj");
|
|
exportObjToFilename(filename);
|
|
}
|
|
|
|
void DocumentWindow::exportObjToFilename(const QString& filename)
|
|
{
|
|
QApplication::setOverrideCursor(Qt::WaitCursor);
|
|
ModelMesh* resultMesh = m_document->takeResultMesh();
|
|
if (nullptr != resultMesh) {
|
|
resultMesh->exportAsObj(filename);
|
|
delete resultMesh;
|
|
}
|
|
QApplication::restoreOverrideCursor();
|
|
}
|
|
|
|
void DocumentWindow::exportFbxResult()
|
|
{
|
|
QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
|
|
tr("Autodesk FBX (*.fbx)"));
|
|
if (filename.isEmpty()) {
|
|
return;
|
|
}
|
|
ensureFileExtension(&filename, ".fbx");
|
|
exportFbxToFilename(filename);
|
|
}
|
|
|
|
void DocumentWindow::exportFbxToFilename(const QString& filename)
|
|
{
|
|
if (!m_document->isExportReady()) {
|
|
qDebug() << "Export but document is not export ready";
|
|
return;
|
|
}
|
|
QApplication::setOverrideCursor(Qt::WaitCursor);
|
|
dust3d::Object skeletonResult = m_document->currentUvMappedObject();
|
|
FbxFileWriter fbxFileWriter(skeletonResult,
|
|
filename,
|
|
m_document->textureImage,
|
|
m_document->textureNormalImage,
|
|
m_document->textureMetalnessImage,
|
|
m_document->textureRoughnessImage,
|
|
m_document->textureAmbientOcclusionImage);
|
|
fbxFileWriter.save();
|
|
QApplication::restoreOverrideCursor();
|
|
}
|
|
|
|
void DocumentWindow::exportGlbResult()
|
|
{
|
|
QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
|
|
tr("glTF Binary Format (*.glb)"));
|
|
if (filename.isEmpty()) {
|
|
return;
|
|
}
|
|
ensureFileExtension(&filename, ".glb");
|
|
exportGlbToFilename(filename);
|
|
}
|
|
|
|
void DocumentWindow::exportGlbToFilename(const QString& filename)
|
|
{
|
|
if (!m_document->isExportReady()) {
|
|
qDebug() << "Export but document is not export ready";
|
|
return;
|
|
}
|
|
QApplication::setOverrideCursor(Qt::WaitCursor);
|
|
dust3d::Object skeletonResult = m_document->currentUvMappedObject();
|
|
QImage* textureMetalnessRoughnessAmbientOcclusionImage = UvMapGenerator::combineMetalnessRoughnessAmbientOcclusionImages(m_document->textureMetalnessImage,
|
|
m_document->textureRoughnessImage,
|
|
m_document->textureAmbientOcclusionImage);
|
|
GlbFileWriter glbFileWriter(skeletonResult, filename,
|
|
m_document->textureImage, m_document->textureNormalImage, textureMetalnessRoughnessAmbientOcclusionImage);
|
|
glbFileWriter.save();
|
|
delete textureMetalnessRoughnessAmbientOcclusionImage;
|
|
QApplication::restoreOverrideCursor();
|
|
}
|
|
|
|
void DocumentWindow::updateXlockButtonState()
|
|
{
|
|
if (m_document->xlocked)
|
|
m_xLockButton->setIcon(":/resources/toolbar_x_disabled.svg");
|
|
else
|
|
m_xLockButton->setIcon(":/resources/toolbar_x.svg");
|
|
}
|
|
|
|
void DocumentWindow::updateYlockButtonState()
|
|
{
|
|
if (m_document->ylocked)
|
|
m_yLockButton->setIcon(":/resources/toolbar_y_disabled.svg");
|
|
else
|
|
m_yLockButton->setIcon(":/resources/toolbar_y.svg");
|
|
}
|
|
|
|
void DocumentWindow::updateZlockButtonState()
|
|
{
|
|
if (m_document->zlocked)
|
|
m_zLockButton->setIcon(":/resources/toolbar_z_disabled.svg");
|
|
else
|
|
m_zLockButton->setIcon(":/resources/toolbar_z.svg");
|
|
}
|
|
|
|
void DocumentWindow::updateRadiusLockButtonState()
|
|
{
|
|
if (m_document->radiusLocked)
|
|
m_radiusLockButton->setIcon(":/resources/toolbar_radius_disabled.svg");
|
|
else
|
|
m_radiusLockButton->setIcon(":/resources/toolbar_radius.svg");
|
|
}
|
|
|
|
void DocumentWindow::registerDialog(QWidget* widget)
|
|
{
|
|
m_dialogs.push_back(widget);
|
|
}
|
|
|
|
void DocumentWindow::unregisterDialog(QWidget* widget)
|
|
{
|
|
m_dialogs.erase(std::remove(m_dialogs.begin(), m_dialogs.end(), widget), m_dialogs.end());
|
|
}
|
|
|
|
void DocumentWindow::setExportWaitingList(const QStringList& filenames)
|
|
{
|
|
m_waitingForExportToFilenames = filenames;
|
|
}
|
|
|
|
void DocumentWindow::checkExportWaitingList()
|
|
{
|
|
if (m_waitingForExportToFilenames.empty())
|
|
return;
|
|
|
|
auto list = m_waitingForExportToFilenames;
|
|
m_waitingForExportToFilenames.clear();
|
|
|
|
bool isSuccessful = m_document->isMeshGenerationSucceed();
|
|
for (const auto& filename : list) {
|
|
if (filename.endsWith(".obj")) {
|
|
exportObjToFilename(filename);
|
|
emit waitingExportFinished(filename, isSuccessful);
|
|
} else if (filename.endsWith(".fbx")) {
|
|
exportFbxToFilename(filename);
|
|
emit waitingExportFinished(filename, isSuccessful);
|
|
} else if (filename.endsWith(".glb")) {
|
|
exportGlbToFilename(filename);
|
|
emit waitingExportFinished(filename, isSuccessful);
|
|
} else {
|
|
emit waitingExportFinished(filename, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DocumentWindow::generateComponentPreviewImages()
|
|
{
|
|
if (nullptr != m_componentPreviewImagesGenerator) {
|
|
m_isComponentPreviewImagesObsolete = true;
|
|
return;
|
|
}
|
|
|
|
m_isComponentPreviewImagesObsolete = false;
|
|
|
|
QThread* thread = new QThread;
|
|
|
|
m_componentPreviewImagesGenerator = new MeshPreviewImagesGenerator(new ModelOffscreenRender(m_modelRenderWidget->format()));
|
|
for (auto& component : m_document->componentMap) {
|
|
if (!component.second.isPreviewMeshObsolete)
|
|
continue;
|
|
component.second.isPreviewMeshObsolete = false;
|
|
auto previewMesh = std::unique_ptr<ModelMesh>(component.second.takePreviewMesh());
|
|
bool useFrontView = false;
|
|
if (!component.second.linkToPartId.isNull()) {
|
|
const auto& part = m_document->findPart(component.second.linkToPartId);
|
|
if (nullptr != part) {
|
|
if (dust3d::PartTarget::CutFace == part->target)
|
|
useFrontView = true;
|
|
if (!part->colorImageId.isNull()) {
|
|
const auto& colorImage = ImageForever::get(part->colorImageId);
|
|
if (nullptr != colorImage) {
|
|
previewMesh->setTextureImage(new QImage(*colorImage));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_componentPreviewImagesGenerator->addInput(component.first, std::move(previewMesh), useFrontView);
|
|
}
|
|
m_componentPreviewImagesGenerator->moveToThread(thread);
|
|
connect(thread, &QThread::started, m_componentPreviewImagesGenerator, &MeshPreviewImagesGenerator::process);
|
|
connect(m_componentPreviewImagesGenerator, &MeshPreviewImagesGenerator::finished, this, &DocumentWindow::componentPreviewImagesReady);
|
|
connect(m_componentPreviewImagesGenerator, &MeshPreviewImagesGenerator::finished, thread, &QThread::quit);
|
|
connect(thread, &QThread::finished, thread, &QThread::deleteLater);
|
|
thread->start();
|
|
|
|
updateInprogressIndicator();
|
|
}
|
|
|
|
void DocumentWindow::componentPreviewImagesReady()
|
|
{
|
|
std::unique_ptr<std::map<dust3d::Uuid, QImage>> componentImages;
|
|
componentImages.reset(m_componentPreviewImagesGenerator->takeImages());
|
|
if (nullptr != componentImages) {
|
|
for (const auto& it : *componentImages) {
|
|
m_document->setComponentPreviewImage(it.first, std::make_unique<QImage>(std::move(it.second)));
|
|
}
|
|
}
|
|
|
|
decorateComponentPreviewImages();
|
|
|
|
delete m_componentPreviewImagesGenerator;
|
|
m_componentPreviewImagesGenerator = nullptr;
|
|
|
|
if (m_isComponentPreviewImagesObsolete)
|
|
generateComponentPreviewImages();
|
|
else
|
|
updateInprogressIndicator();
|
|
}
|
|
|
|
void DocumentWindow::decorateComponentPreviewImages()
|
|
{
|
|
if (nullptr != m_componentPreviewImagesDecorator) {
|
|
m_isComponentPreviewImageDecorationsObsolete = true;
|
|
return;
|
|
}
|
|
|
|
m_isComponentPreviewImageDecorationsObsolete = false;
|
|
|
|
QThread* thread = new QThread;
|
|
|
|
auto previewInputs = std::make_unique<std::vector<ComponentPreviewImagesDecorator::PreviewInput>>();
|
|
for (auto& component : m_document->componentMap) {
|
|
if (!component.second.isPreviewImageDecorationObsolete)
|
|
continue;
|
|
component.second.isPreviewImageDecorationObsolete = false;
|
|
if (nullptr == component.second.previewImage)
|
|
continue;
|
|
previewInputs->emplace_back(ComponentPreviewImagesDecorator::PreviewInput {
|
|
component.first,
|
|
std::make_unique<QImage>(*component.second.previewImage),
|
|
!component.second.childrenIds.empty() });
|
|
}
|
|
m_componentPreviewImagesDecorator = std::make_unique<ComponentPreviewImagesDecorator>(std::move(previewInputs));
|
|
m_componentPreviewImagesDecorator->moveToThread(thread);
|
|
connect(thread, &QThread::started, m_componentPreviewImagesDecorator.get(), &ComponentPreviewImagesDecorator::process);
|
|
connect(m_componentPreviewImagesDecorator.get(), &ComponentPreviewImagesDecorator::finished, this, &DocumentWindow::componentPreviewImageDecorationsReady);
|
|
connect(m_componentPreviewImagesDecorator.get(), &ComponentPreviewImagesDecorator::finished, thread, &QThread::quit);
|
|
connect(thread, &QThread::finished, thread, &QThread::deleteLater);
|
|
thread->start();
|
|
|
|
updateInprogressIndicator();
|
|
}
|
|
|
|
void DocumentWindow::componentPreviewImageDecorationsReady()
|
|
{
|
|
auto resultImages = m_componentPreviewImagesDecorator->takeResultImages();
|
|
if (nullptr != resultImages) {
|
|
for (auto& it : *resultImages) {
|
|
if (nullptr == it.second)
|
|
continue;
|
|
m_document->setComponentPreviewPixmap(it.first, QPixmap::fromImage(*it.second));
|
|
}
|
|
}
|
|
|
|
m_componentPreviewImagesDecorator.reset();
|
|
|
|
if (m_isComponentPreviewImageDecorationsObsolete)
|
|
decorateComponentPreviewImages();
|
|
else
|
|
updateInprogressIndicator();
|
|
}
|
|
|
|
ModelWidget* DocumentWindow::modelWidget()
|
|
{
|
|
return m_modelRenderWidget;
|
|
}
|
|
|
|
QShortcut* DocumentWindow::createShortcut(QKeySequence key)
|
|
{
|
|
auto shortcutIt = m_shortcutMap.find(key);
|
|
if (shortcutIt != m_shortcutMap.end())
|
|
return shortcutIt->second;
|
|
QShortcut* shortcut = new QShortcut(this);
|
|
shortcut->setKey(key);
|
|
m_shortcutMap.insert({ key, shortcut });
|
|
return shortcut;
|
|
}
|
|
|
|
#define defineShortcut(keyVal, widget, funcName) \
|
|
QObject::connect(createShortcut(keyVal), &QShortcut::activated, widget, funcName)
|
|
|
|
void DocumentWindow::initializeToolShortcuts(SkeletonGraphicsWidget* graphicsWidget)
|
|
{
|
|
defineShortcut(Qt::Key_A, graphicsWidget, &SkeletonGraphicsWidget::shortcutAddMode);
|
|
defineShortcut(Qt::CTRL + Qt::Key_A, graphicsWidget, &SkeletonGraphicsWidget::shortcutSelectAll);
|
|
defineShortcut(Qt::CTRL + Qt::Key_Z, graphicsWidget, &SkeletonGraphicsWidget::shortcutUndo);
|
|
defineShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_Z, graphicsWidget, &SkeletonGraphicsWidget::shortcutRedo);
|
|
defineShortcut(Qt::CTRL + Qt::Key_Y, graphicsWidget, &SkeletonGraphicsWidget::shortcutRedo);
|
|
defineShortcut(Qt::Key_Z, graphicsWidget, &SkeletonGraphicsWidget::shortcutZlock);
|
|
defineShortcut(Qt::Key_Y, graphicsWidget, &SkeletonGraphicsWidget::shortcutYlock);
|
|
defineShortcut(Qt::Key_X, graphicsWidget, &SkeletonGraphicsWidget::shortcutXlock);
|
|
defineShortcut(Qt::Key_S, graphicsWidget, &SkeletonGraphicsWidget::shortcutSelectMode);
|
|
defineShortcut(Qt::Key_R, graphicsWidget, &SkeletonGraphicsWidget::shortcutToggleRotation);
|
|
defineShortcut(Qt::Key_O, graphicsWidget, &SkeletonGraphicsWidget::shortcutToggleFlatShading);
|
|
defineShortcut(Qt::Key_W, graphicsWidget, &SkeletonGraphicsWidget::shortcutToggleWireframe);
|
|
defineShortcut(Qt::Key_Escape, graphicsWidget, &SkeletonGraphicsWidget::shortcutEscape);
|
|
}
|
|
|
|
void DocumentWindow::initializeCanvasShortcuts(SkeletonGraphicsWidget* graphicsWidget)
|
|
{
|
|
defineShortcut(Qt::Key_Delete, graphicsWidget, &SkeletonGraphicsWidget::shortcutDelete);
|
|
defineShortcut(Qt::Key_Backspace, graphicsWidget, &SkeletonGraphicsWidget::shortcutDelete);
|
|
defineShortcut(Qt::CTRL + Qt::Key_X, graphicsWidget, &SkeletonGraphicsWidget::shortcutCut);
|
|
defineShortcut(Qt::CTRL + Qt::Key_C, graphicsWidget, &SkeletonGraphicsWidget::shortcutCopy);
|
|
defineShortcut(Qt::CTRL + Qt::Key_V, graphicsWidget, &SkeletonGraphicsWidget::shortcutPaste);
|
|
defineShortcut(Qt::ALT + Qt::Key_Minus, graphicsWidget, &SkeletonGraphicsWidget::shortcutZoomRenderedModelByMinus10);
|
|
defineShortcut(Qt::Key_Minus, graphicsWidget, &SkeletonGraphicsWidget::shortcutZoomSelectedByMinus1);
|
|
defineShortcut(Qt::ALT + Qt::Key_Equal, graphicsWidget, &SkeletonGraphicsWidget::shortcutZoomRenderedModelBy10);
|
|
defineShortcut(Qt::Key_Equal, graphicsWidget, &SkeletonGraphicsWidget::shortcutZoomSelectedBy1);
|
|
defineShortcut(Qt::Key_Comma, graphicsWidget, &SkeletonGraphicsWidget::shortcutRotateSelectedByMinus1);
|
|
defineShortcut(Qt::Key_Period, graphicsWidget, &SkeletonGraphicsWidget::shortcutRotateSelectedBy1);
|
|
defineShortcut(Qt::Key_Left, graphicsWidget, &SkeletonGraphicsWidget::shortcutMoveSelectedToLeft);
|
|
defineShortcut(Qt::Key_Right, graphicsWidget, &SkeletonGraphicsWidget::shortcutMoveSelectedToRight);
|
|
defineShortcut(Qt::Key_Up, graphicsWidget, &SkeletonGraphicsWidget::shortcutMoveSelectedToUp);
|
|
defineShortcut(Qt::Key_Down, graphicsWidget, &SkeletonGraphicsWidget::shortcutMoveSelectedToDown);
|
|
defineShortcut(Qt::Key_BracketLeft, graphicsWidget, &SkeletonGraphicsWidget::shortcutScaleSelectedByMinus1);
|
|
defineShortcut(Qt::Key_BracketRight, graphicsWidget, &SkeletonGraphicsWidget::shortcutScaleSelectedBy1);
|
|
defineShortcut(Qt::Key_E, graphicsWidget, &SkeletonGraphicsWidget::shortcutSwitchProfileOnSelected);
|
|
defineShortcut(Qt::Key_H, graphicsWidget, &SkeletonGraphicsWidget::shortcutShowOrHideSelectedPart);
|
|
defineShortcut(Qt::Key_J, graphicsWidget, &SkeletonGraphicsWidget::shortcutEnableOrDisableSelectedPart);
|
|
defineShortcut(Qt::Key_L, graphicsWidget, &SkeletonGraphicsWidget::shortcutLockOrUnlockSelectedPart);
|
|
defineShortcut(Qt::Key_F, graphicsWidget, &SkeletonGraphicsWidget::shortcutCheckPartComponent);
|
|
}
|
|
|
|
void DocumentWindow::initializeShortcuts()
|
|
{
|
|
initializeToolShortcuts(m_canvasGraphicsWidget);
|
|
initializeCanvasShortcuts(m_canvasGraphicsWidget);
|
|
|
|
defineShortcut(Qt::Key_M, m_canvasGraphicsWidget, &SkeletonGraphicsWidget::shortcutXmirrorOnOrOffSelectedPart);
|
|
defineShortcut(Qt::Key_B, m_canvasGraphicsWidget, &SkeletonGraphicsWidget::shortcutSubdivedOrNotSelectedPart);
|
|
defineShortcut(Qt::Key_U, m_canvasGraphicsWidget, &SkeletonGraphicsWidget::shortcutRoundEndOrNotSelectedPart);
|
|
defineShortcut(Qt::Key_C, m_canvasGraphicsWidget, &SkeletonGraphicsWidget::shortcutChamferedOrNotSelectedPart);
|
|
}
|
|
|
|
void DocumentWindow::openRecentFile()
|
|
{
|
|
if (!m_documentSaved) {
|
|
QMessageBox::StandardButton answer = QMessageBox::question(this,
|
|
APP_NAME,
|
|
tr("Do you really want to open another file and lose the unsaved changes?"),
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (answer != QMessageBox::Yes)
|
|
return;
|
|
}
|
|
|
|
QAction* action = qobject_cast<QAction*>(sender());
|
|
if (action) {
|
|
QString fileName = action->data().toString();
|
|
openPathAs(fileName, fileName);
|
|
}
|
|
}
|
|
|
|
void DocumentWindow::updateRecentFileActions()
|
|
{
|
|
QStringList files = Preferences::instance().recentFileList();
|
|
|
|
for (int i = 0; i < (int)files.size() && i < (int)m_recentFileActions.size(); ++i) {
|
|
QString text = tr("&%1 %2").arg(i + 1).arg(strippedName(files[i]));
|
|
m_recentFileActions[i]->setText(text);
|
|
m_recentFileActions[i]->setData(files[i]);
|
|
m_recentFileActions[i]->setVisible(true);
|
|
}
|
|
for (int j = files.size(); j < (int)m_recentFileActions.size(); ++j)
|
|
m_recentFileActions[j]->setVisible(false);
|
|
|
|
m_recentFileSeparatorAction->setVisible(files.size() > 0);
|
|
}
|
|
|
|
QString DocumentWindow::strippedName(const QString& fullFileName)
|
|
{
|
|
return QFileInfo(fullFileName).fileName();
|
|
}
|
|
|
|
bool DocumentWindow::isWorking()
|
|
{
|
|
return nullptr == m_inprogressIndicator || m_inprogressIndicator->isSpinning();
|
|
}
|
|
|
|
void DocumentWindow::toggleRenderColor()
|
|
{
|
|
m_modelRemoveColor = !m_modelRemoveColor;
|
|
forceUpdateRenderModel();
|
|
}
|
|
|
|
void DocumentWindow::generateBonePreviewImages()
|
|
{
|
|
if (nullptr != m_bonePreviewImagesGenerator) {
|
|
m_isBonePreviewImagesObsolete = true;
|
|
return;
|
|
}
|
|
|
|
m_isBonePreviewImagesObsolete = false;
|
|
|
|
QThread* thread = new QThread;
|
|
|
|
m_bonePreviewImagesGenerator = new MeshPreviewImagesGenerator(new ModelOffscreenRender(m_modelRenderWidget->format()));
|
|
for (auto& bone : m_document->boneMap) {
|
|
if (!bone.second.isPreviewMeshObsolete)
|
|
continue;
|
|
bone.second.isPreviewMeshObsolete = false;
|
|
auto previewMesh = std::unique_ptr<ModelMesh>(bone.second.takePreviewMesh());
|
|
const bool useFrontView = false;
|
|
m_bonePreviewImagesGenerator->addInput(bone.first, std::move(previewMesh), useFrontView);
|
|
}
|
|
m_bonePreviewImagesGenerator->moveToThread(thread);
|
|
connect(thread, &QThread::started, m_bonePreviewImagesGenerator, &MeshPreviewImagesGenerator::process);
|
|
connect(m_bonePreviewImagesGenerator, &MeshPreviewImagesGenerator::finished, this, &DocumentWindow::bonePreviewImagesReady);
|
|
connect(m_bonePreviewImagesGenerator, &MeshPreviewImagesGenerator::finished, thread, &QThread::quit);
|
|
connect(thread, &QThread::finished, thread, &QThread::deleteLater);
|
|
thread->start();
|
|
|
|
updateInprogressIndicator();
|
|
}
|
|
|
|
void DocumentWindow::bonePreviewImagesReady()
|
|
{
|
|
std::unique_ptr<std::map<dust3d::Uuid, QImage>> boneImages;
|
|
boneImages.reset(m_bonePreviewImagesGenerator->takeImages());
|
|
if (nullptr != boneImages) {
|
|
for (const auto& it : *boneImages) {
|
|
m_document->setBonePreviewPixmap(it.first, QPixmap::fromImage(it.second));
|
|
}
|
|
}
|
|
|
|
delete m_bonePreviewImagesGenerator;
|
|
m_bonePreviewImagesGenerator = nullptr;
|
|
|
|
if (m_isBonePreviewImagesObsolete)
|
|
generateBonePreviewImages();
|
|
else
|
|
updateInprogressIndicator();
|
|
}
|
|
|
|
void DocumentWindow::forceUpdateRenderModel()
|
|
{
|
|
ModelMesh* mesh = nullptr;
|
|
if (m_showBodyBonePreview) {
|
|
mesh = m_document->takeResultBodyBonePreviewMesh();
|
|
m_currentUpdatedMeshId = m_document->resultBodyBonePreviewMeshId();
|
|
} else {
|
|
if (m_document->isMeshGenerating() || m_document->isPostProcessing() || m_document->isTextureGenerating()) {
|
|
mesh = m_document->takeResultMesh();
|
|
m_currentUpdatedMeshId = m_document->resultMeshId();
|
|
} else {
|
|
mesh = m_document->takeResultTextureMesh();
|
|
m_currentUpdatedMeshId = m_document->resultTextureMeshId();
|
|
}
|
|
if (m_modelRemoveColor && mesh)
|
|
mesh->removeColor();
|
|
}
|
|
m_modelRenderWidget->updateMesh(mesh);
|
|
}
|
|
|
|
void DocumentWindow::updateRenderModel()
|
|
{
|
|
qint64 shouldShowId = 0;
|
|
if (m_document->isMeshGenerating() || m_document->isPostProcessing() || m_document->isTextureGenerating()) {
|
|
shouldShowId = m_document->resultMeshId();
|
|
} else {
|
|
shouldShowId = -(qint64)m_document->resultTextureMeshId();
|
|
}
|
|
if (shouldShowId == m_currentUpdatedMeshId)
|
|
return;
|
|
if (std::abs(shouldShowId) < std::abs(m_currentUpdatedMeshId))
|
|
return;
|
|
forceUpdateRenderModel();
|
|
}
|
|
|
|
void DocumentWindow::forceUpdateRenderWireframe()
|
|
{
|
|
m_modelRenderWidget->updateWireframeMesh(m_document->takeWireframeMesh());
|
|
m_currentUpdatedWireframeId = m_document->resultMeshId();
|
|
}
|
|
|
|
void DocumentWindow::updateRenderWireframe()
|
|
{
|
|
if (m_document->resultMeshId() == m_currentUpdatedWireframeId)
|
|
return;
|
|
forceUpdateRenderWireframe();
|
|
}
|