diff options
Diffstat (limited to 'tools/ArtistTools/source/CoreLib/Window')
24 files changed, 4406 insertions, 0 deletions
diff --git a/tools/ArtistTools/source/CoreLib/Window/AppMainWindow.cpp b/tools/ArtistTools/source/CoreLib/Window/AppMainWindow.cpp new file mode 100644 index 0000000..3a85d8b --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/AppMainWindow.cpp @@ -0,0 +1,1448 @@ +#include <QtWidgets/QShortcut> +#include <QtWidgets/QAction> +#include <QtWidgets/QMenu> +#include <QtWidgets/QFileDialog> +#include <QtWidgets/QMessageBox> +#include <QtGui/QDesktopServices> +#include <QtWidgets/QScrollBar> +#include <QtWidgets/QGraphicsEllipseItem> +#include <QtWidgets/QGraphicsView> +#include <QtWidgets/QProgressDialog> + +#include <Windows.h> + +#include "AppMainWindow.h" +#include "ExpandablePanel.h" + +#include "D3DWidget.h" + +#include "DisplayMeshesPanel.h" + +#include "DisplayPreferencesPanel.h" +#include "DisplayScenePanel.h" +#include "DisplayLightPanel.h" +#include "ui_DisplayPreferencesPanel.h" +#include "ui_DisplayScenePanel.h" +#include "ui_DisplayLightPanel.h" +#include "CameraBookmarksDialog.h" + +#include "SimpleScene.h" +#include "GlobalSettings.h" + +#include "ViewerOutput.h" +#include "Gamepad.h" +#if USE_CURVE_EDITOR +#include "CurveEditorMainWindow.h" +#endif +#ifndef NV_ARTISTTOOLS +#include "ui_AppMainToolbar.h" +#include "ui_AssetControlPanel.h" +#include "ui_GeneralAttributesPanel.h" +#include "ui_PhysicalMaterialsPanel.h" +#include "ui_StyleMaterialsPanel.h" +#include "ui_GraphicalMaterialsPanel.h" +#include "BlastToolbar.h" +#include "AssetControlPanel.h" +#include "GraphicalMaterialPanel.h" +#include "PhysicalMaterialPanel.h" +#include "StyleMaterialPanel.h" +#include "GeneralAttributePanel.h" +#include "MaterialSetPanel.h" +#include "LodPanel.h" +#include "DisplayVisualizersPanel.h" +#include "ui_DisplayVisualizersPanel.h" +#include "DisplayMeshMaterialsPanel.h" +#include "FurCharacter.h" +#include "HairParams.h" +#include "AboutDialog.h" +#else +#endif // NV_ARTISTTOOLS + +class MsgPrinter : public FrontPrinter +{ +public: + MsgPrinter(QTextBrowser* browser):_browser(browser) + { + + } + + void print(const char* txt, unsigned long color /* = 0 */, Effect e /* = NONE */) + { + if(color == 0 && e == FrontPrinter::NONE) + { + _browser->insertPlainText(QString(txt)+"\n"); + } + else + { + // output html text + QString surfix; + QString postfix; + surfix.reserve(64); + postfix.reserve(64); + if(e & FrontPrinter::BOLD) + { + surfix = surfix + "<b>"; + postfix= postfix + "</b>"; + } + else if(e & FrontPrinter::UNDERLINE) + { + surfix = surfix + "<u>"; + postfix= QString("</u>") + postfix; + } + else if(e & FrontPrinter::ITALIC) + { + surfix = surfix + "<i>"; + postfix= QString("</i>") + postfix; + } + + if(color != 0) + { + int r = GetRValue(color); + int g = GetGValue(color); + int b = GetBValue(color); + + surfix = QString("<div style=\"color:rgb(%1,%2,%3);\">").arg(r).arg(g).arg(b) + surfix; + postfix= postfix + QString("</div><br />"); + } + + QString html = surfix + QString(txt) + postfix; + _browser->insertHtml(html); + } + // auto scroll to the bottom + QScrollBar *sb = _browser->verticalScrollBar(); + if (sb) sb->setValue(sb->maximum()); + } + +private: + QTextBrowser* _browser; +}; + +int AppMainWindow::_connectionMode = 0; +bool AppMainWindow::_expertMode = false; +AppMainWindow* gAppMainWindow = NV_NULL; + +void CreateAppMainWindow() +{ + gAppMainWindow = new AppMainWindow; +} + +void ReleaseAppMainWindow() +{ + delete gAppMainWindow; + gAppMainWindow = NV_NULL; +} + +AppMainWindow& AppMainWindow::Inst() +{ + return *gAppMainWindow; +} + +AppMainWindow::AppMainWindow(QWidget *parent, Qt::WindowFlags flags) + : QMainWindow(parent, flags) + , _bookmarksMenu(0) + ,_displayMeshesPanel(0) + , _displayPreferencesPanel(0) + , _displayScenePanel(0) + ,_displayLightPanel(0) +#if USE_CURVE_EDITOR + ,_curveEditorInitizlized(false) + , _curveEditorMainWindow(nullptr) +#endif + ,_bookmarkActionGroup(0) + ,_actionAddBookmark(0) + ,_actionEditBookmarks(0) +{ + setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea); + setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea); + + ui.setupUi(this); + //ui.dockOutputWindow->hide(); + +#ifndef NV_ARTISTTOOLS + _mainToolbar = 0; + _physicalMaterialPanel = 0; + _styleMaterialPanel = 0; + _graphicalMaterialPanel = 0; + _displayFurVisualizersPanel = 0; + _assetControlPanel = 0; + _generalAttributePanel = 0; + _lodPanel = 0; + _displayMeshMaterialsPanel; +#if USE_MATERIAL_SET + _materialSetPanel = 0; +#endif +#else + CoreLib::Inst()->AppMainWindow_AppMainWindow(); +#endif // NV_ARTISTTOOLS + + _progressDialog.close(); // prevent show one empty progress dialog when it runs. + + m_bGizmoWithLocal = false; +} + +void AppMainWindow::InitUI() +{ + _d3dWidget = new D3DWidget(this); + _d3dWidget->setMinimumSize(200, 200); + ui.renderLayout->addWidget(_d3dWidget); + + InitShortCuts(); + InitMenuItems(); + InitToolbar(); + InitPluginTab(); + InitMainTab(); + + InitMouseSchemes(); + + updateUI(); + + if (_connectionMode == 1) // master mode + ui.sideBarTab->removeTab(1); + + if (_connectionMode == 2) + ui.sideBarTab->removeTab(0); + + + QString defFilePath; + + QString appDir = qApp->applicationDirPath(); + QDir dir(appDir); + if (dir.cd("../../media")) + defFilePath = dir.absolutePath(); + + _lastFilePath = defFilePath; + + _navigationStyle = 0; + + // initialize the message printer + _printer = new MsgPrinter(this->ui.outputWindow); + ViewerOutput::Inst().RegisterPrinter(_printer); + +#ifndef NV_ARTISTTOOLS + + viewer_info( + "<a href=\"https://developer.nvidia.com/hairworks\" style=\"color:rgb(118,180,0);\">NVIDIA Blast Version v" + NV_HAIR_RELEASE_VERSION_STRING + "</a>"); + +#else + CoreLib::Inst()->AppMainWindow_InitUI(); +#endif // NV_ARTISTTOOLS +} + +AppMainWindow::~AppMainWindow() +{ +} + +void AppMainWindow::setConnectionMode(int m) +{ + _connectionMode = m; +} + +void AppMainWindow::startProgress() +{ + _progressDialog.setWindowModality(Qt::WindowModal); + _progressDialog.show(); +} + +void AppMainWindow::setProgress(const char* label, int progress) +{ + _progressDialog.setLabelText(label); + if (progress >= 0) + _progressDialog.setValue(progress); + + _progressDialog.update(); +} + +void AppMainWindow::endProgress() +{ + _progressDialog.close(); +} + +void AppMainWindow::quit() +{ + emit aboutToQuit(); +} + +void AppMainWindow::setProgressMaximum(int m) +{ + _progressDialog.setMaximum(m); +} + +void AppMainWindow::InitMenuItems() +{ + QMenuBar* menu = ui.menuBar; + QAction* act = NV_NULL; + + // file sub-menu + QMenu* fileMenu = menu->addMenu("&File"); + + if (_connectionMode != 1) + { + act = new QAction("Clear scene", this); + act->setShortcut(QKeySequence::New); + connect(act, SIGNAL(triggered()), this, SLOT(menu_clearScene())); + fileMenu->addAction(act); + + fileMenu->addSeparator(); + + act = new QAction("Open fbx file", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_openfbx())); + fileMenu->addAction(act); + + fileMenu->addSeparator(); + +#ifndef NV_ARTISTTOOLS + fileMenu->addSeparator(); + act = new QAction("Open project file", this); + act->setShortcut(QKeySequence::Open); + connect(act, SIGNAL(triggered()), this, SLOT(menu_openProject())); + fileMenu->addAction(act); + + act = new QAction("Save project file", this); + act->setShortcut(QKeySequence::Save); + connect(act, SIGNAL(triggered()), this, SLOT(menu_saveProject())); + fileMenu->addAction(act); + + act = new QAction("Save project file as...", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_saveProjectAs())); + fileMenu->addAction(act); + + fileMenu->addSeparator(); + + act = new QAction("&Open hair file", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_openHair())); + fileMenu->addAction(act); + + act = new QAction("&Save hair file", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_saveHair())); + fileMenu->addAction(act); + + act = new QAction("Save hair file as...", this); + act->setShortcut(QKeySequence::SaveAs); + connect(act, SIGNAL(triggered()), this, SLOT(menu_saveHairAs())); + fileMenu->addAction(act); + + act = new QAction("Save all hairs...", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_saveAllHairs())); + fileMenu->addAction(act); + + fileMenu->addSeparator(); +#else + CoreLib::Inst()->AppMainWindow_InitMenuItems(ui.menuBar); +#endif // NV_ARTISTTOOLS + } + + act = new QAction("E&xit", this); + act->setShortcut(QKeySequence::Quit); + connect(act, SIGNAL(triggered()), this, SLOT(close())); + fileMenu->addAction(act); + + // view submenu + QMenu* viewMenu = menu->addMenu("&View"); + act = new QAction("Bookmarks", this); + //connect(act, SIGNAL(triggered()), this, SLOT(menu_showOutput())); + viewMenu->addAction(act); + _bookmarksMenu = new QMenu("Bookmarks", this); + connect(_bookmarksMenu, SIGNAL(triggered(QAction*)), this, SLOT(menu_bookmarkTriggered(QAction*))); + act->setMenu(_bookmarksMenu); + act = new QAction("Add Bookmark", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_addBookmark())); + _bookmarksMenu->addAction(act); + _actionAddBookmark = act; + act = new QAction("Edit Bookmarks", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_editBookmarks())); + _bookmarksMenu->addAction(act); + _actionEditBookmarks = act; + _bookmarksMenu->addSeparator(); + _bookmarkActionGroup = new QActionGroup(this); + + // window submenu + QMenu* windowMenu = menu->addMenu("&Window"); + act = new QAction("Output", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_showOutput())); + windowMenu->addAction(act); + + act = new QAction("Attribute Editor", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_showAttributeEditor())); + windowMenu->addAction(act); + +#if USE_CURVE_EDITOR + act = new QAction("Curve Editor", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_showCurveEditor())); + windowMenu->addAction(act); +#endif + + // help submenu + QMenu* helpMenu = menu->addMenu("&Help"); + + act = new QAction("Documentation", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_opendoc())); + helpMenu->addAction(act); + + act = new QAction("&About", this); + connect(act, SIGNAL(triggered()), this, SLOT(menu_about())); + helpMenu->addAction(act); +} + +void AppMainWindow::InitToolbar() +{ + if (_connectionMode != 1) + { +#ifndef NV_ARTISTTOOLS + _mainToolbar = new BlastToolbar(ui.centralWidget); + ui.verticalLayout->insertWidget(0, _mainToolbar); + connect(_mainToolbar->getUI().btnFileOpen, SIGNAL(clicked()), this, SLOT(menu_openProject())); +#else + CoreLib::Inst()->AppMainWindow_InitToolbar(ui.centralWidget, ui.verticalLayout); +#endif // NV_ARTISTTOOLS + } +} + +void AppMainWindow::InitPluginTab() +{ +#ifndef NV_ARTISTTOOLS + QWidget *tabFur; + QGridLayout *gridLayout; + QFrame *furMaterialEditorArea; + QVBoxLayout *furMaterialEditorAreaLayout; + QScrollArea *furScrollArea; + QWidget *furScrollAreaContents; + QVBoxLayout *furScrollAreaLayout; + QSpacerItem *verticalSpacer; + + tabFur = new QWidget(); + tabFur->setObjectName(QStringLiteral("tabFur")); + gridLayout = new QGridLayout(tabFur); + gridLayout->setSpacing(6); + gridLayout->setContentsMargins(11, 11, 11, 11); + gridLayout->setObjectName(QStringLiteral("gridLayout")); + gridLayout->setContentsMargins(0, 0, 0, 0); + furMaterialEditorArea = new QFrame(tabFur); + furMaterialEditorArea->setObjectName(QStringLiteral("furMaterialEditorArea")); + furMaterialEditorAreaLayout = new QVBoxLayout(furMaterialEditorArea); + furMaterialEditorAreaLayout->setSpacing(6); + furMaterialEditorAreaLayout->setContentsMargins(11, 11, 11, 11); + furMaterialEditorAreaLayout->setObjectName(QStringLiteral("furMaterialEditorAreaLayout")); + furMaterialEditorAreaLayout->setContentsMargins(2, 2, 2, 2); + + gridLayout->addWidget(furMaterialEditorArea, 1, 0, 1, 1); + + furScrollArea = new QScrollArea(tabFur); + furScrollArea->setObjectName(QStringLiteral("furScrollArea")); + furScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded); + furScrollArea->setWidgetResizable(true); + furScrollAreaContents = new QWidget(); + furScrollAreaContents->setObjectName(QStringLiteral("furScrollAreaContents")); + furScrollAreaContents->setGeometry(QRect(0, 0, 359, 481)); + furScrollAreaLayout = new QVBoxLayout(furScrollAreaContents); + furScrollAreaLayout->setSpacing(3); + furScrollAreaLayout->setContentsMargins(11, 11, 11, 11); + furScrollAreaLayout->setObjectName(QStringLiteral("furScrollAreaLayout")); + furScrollAreaLayout->setContentsMargins(2, 2, 2, 2); + verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding); + + furScrollAreaLayout->addItem(verticalSpacer); + + furScrollArea->setWidget(furScrollAreaContents); + + gridLayout->addWidget(furScrollArea, 0, 0, 1, 1); + + ui.sideBarTab->addTab(tabFur, QString()); + + ui.sideBarTab->setTabText(ui.sideBarTab->indexOf(tabFur), QApplication::translate("AppMainWindowClass", "Hair", 0)); + + ExpandablePanel* panel = 0; + int pannelCnt = 0; + + if (_connectionMode == 0) + { + panel = new ExpandablePanel(furScrollAreaContents, false); + _generalAttributePanel = new GeneralAttributePanel(panel); + panel->AddContent(_generalAttributePanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("Asset Selection"); + + panel = new ExpandablePanel(furScrollAreaContents, false); + _assetControlPanel = new AssetControlPanel(panel); + panel->AddContent(_assetControlPanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("General Settings"); + + } + + panel = new ExpandablePanel(furScrollAreaContents); + _displayFurVisualizersPanel = new DisplayFurVisualizersPanel(panel); + panel->AddContent(_displayFurVisualizersPanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("Visualization"); + + panel = new ExpandablePanel(furScrollAreaContents); + _physicalMaterialPanel = new PhysicalMaterialPanel(panel); + panel->AddContent(_physicalMaterialPanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("Physical"); + + panel = new ExpandablePanel(furScrollAreaContents); + _styleMaterialPanel = new StyleMaterialPanel(panel); + panel->AddContent(_styleMaterialPanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("Style"); + + panel = new ExpandablePanel(furScrollAreaContents); + _graphicalMaterialPanel = new GraphicalMaterialPanel(panel); + panel->AddContent(_graphicalMaterialPanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("Graphics"); + + panel = new ExpandablePanel(furScrollAreaContents); + _lodPanel = new LodPanel(panel); + panel->AddContent(_lodPanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("Level Of Detail"); + +#if USE_MATERIAL_SET + panel = new ExpandablePanel(furScrollAreaContents); + _materialSetPanel = new MaterialSetPanel(panel); + panel->AddContent(_materialSetPanel); + furScrollAreaLayout->insertWidget(pannelCnt++, panel); + panel->SetTitle("Control Texture Channels"); + //_materialSetPanel->hide(); + //panel->SetCollapsed(true); +#else + ui.furMaterialEditorAreaLayout->setEnabled(false); +#endif +#else + CoreLib::Inst()->AppMainWindow_InitPluginTab(ui.sideBarTab); +#endif // NV_ARTISTTOOLS + +#if USE_CURVE_EDITOR + _curveEditorMainWindow = new nvidia::CurveEditor::CurveEditorMainWindow( this);//nullptr); + _curveEditorMainWindow->setResampleEnabled(false); + ui.dockWidgetCurveEditor->setWidget(_curveEditorMainWindow); + ui.dockWidgetCurveEditor->setWindowTitle(tr("Curve Editor")); + + connect(_curveEditorMainWindow, SIGNAL(CurveAttributeChanged(nvidia::CurveEditor::CurveAttribute*)), this, SLOT(onCurveAttributeChanged(nvidia::CurveEditor::CurveAttribute*))); + connect(_curveEditorMainWindow, SIGNAL(ColorAttributeChanged(nvidia::CurveEditor::ColorAttribute*)), this, SLOT(onColorAttributeChanged(nvidia::CurveEditor::ColorAttribute*))); + connect(_curveEditorMainWindow, SIGNAL(ReloadColorAttributeTexture(nvidia::CurveEditor::ColorAttribute*, bool, int)), this, SLOT(onReloadColorAttributeTexture(nvidia::CurveEditor::ColorAttribute*, bool, int))); +//#else +// ui.furCurveEditorAreaLayout->setEnabled(false); +#endif +} + +void AppMainWindow::InitMainTab() +{ + int idx = 0; + + if (_connectionMode != 1) + { + ExpandablePanel* panel = new ExpandablePanel(ui.displayScrollAreaContents); + _displayPreferencesPanel = new DisplayPreferencesPanel(panel); + panel->AddContent(_displayPreferencesPanel); + ui.displayScrollAreaLayout->insertWidget(idx++, panel); + panel->SetTitle("Preferences"); + + panel = new ExpandablePanel(ui.displayScrollAreaContents); + _displayScenePanel = new DisplayScenePanel(panel); + panel->AddContent(_displayScenePanel); + ui.displayScrollAreaLayout->insertWidget(idx++, panel); + panel->SetTitle("Scene"); + + panel = new ExpandablePanel(ui.displayScrollAreaContents); + _displayLightPanel = new DisplayLightPanel(panel); + panel->AddContent(_displayLightPanel); + ui.displayScrollAreaLayout->insertWidget(idx++, panel); + panel->SetTitle("Light"); + + panel = new ExpandablePanel(ui.displayScrollAreaContents); + _displayMeshesPanel = new DisplayMeshesPanel(panel); + panel->AddContent(_displayMeshesPanel); + ui.displayScrollAreaLayout->insertWidget(idx++, panel); + panel->SetTitle("Display Meshes"); + } + + if (_connectionMode != 1) + { +#ifndef NV_ARTISTTOOLS + ExpandablePanel* panel = new ExpandablePanel(ui.displayScrollAreaContents); + _displayMeshMaterialsPanel = new DisplayMeshMaterialsPanel(panel); + panel->AddContent(_displayMeshMaterialsPanel); + ui.displayScrollAreaLayout->insertWidget(idx++, panel); + panel->SetTitle("Display Mesh Materials"); +#else + CoreLib::Inst()->AppMainWindow_InitMainTab(ui.displayScrollAreaContents, ui.displayScrollAreaLayout, idx); +#endif // NV_ARTISTTOOLS + } +} + +void AppMainWindow::InitShortCuts() +{ + QShortcut* shortCut; + shortCut = new QShortcut(QKeySequence(Qt::Key_F), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_frameall())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_H), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_hud())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_G), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_statistics())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_Space), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_pause())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_B), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_reset())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_Escape), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_escape())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_V), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_expert())); + + shortCut = new QShortcut(QKeySequence("Ctrl+X"), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_expert())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_D), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(demo_next())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_Right), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(demo_next())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_A), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(demo_prev())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_Left), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(demo_prev())); + + shortCut = new QShortcut(QKeySequence(Qt::Key_F2), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_output())); + + shortCut = new QShortcut(QKeySequence("Ctrl+F"), this); + connect(shortCut, SIGNAL(activated()), this, SLOT(shortcut_fitcamera())); +} + +////////////////////////////////////////////////////////////////////////// +void AppMainWindow::updateBookmarkMenu() +{ + // clear old menu items of camera bookmarks + while (_bookmarkActionGroup->actions().size() > 0) + { + QAction* act = _bookmarkActionGroup->actions()[0]; + _bookmarkActionGroup->removeAction(act); + delete act; + } + _bookmarksMenu->clear(); + _bookmarksMenu->addAction(_actionAddBookmark); + _bookmarksMenu->addAction(_actionEditBookmarks); + _bookmarksMenu->addSeparator(); + + QList<QString> bookmarks = SimpleScene::Inst()->getBookmarkNames(); + int numBookmarks = bookmarks.size(); + for (int i = 0; i < numBookmarks; ++i) + { + QString bookmark = bookmarks[i]; + + QAction* act = new QAction(bookmark, this); + act->setCheckable(true); + _bookmarksMenu->addAction(act); + _bookmarkActionGroup->addAction(act); + } + +} + +////////////////////////////////////////////////////////////////////////// +void AppMainWindow::updateUI() +{ + if (_bookmarksMenu && _bookmarkActionGroup) + { + updateBookmarkMenu(); + } + +#ifndef NV_ARTISTTOOLS + if (_mainToolbar) + _mainToolbar->updateValues(); + + if (_graphicalMaterialPanel) + _graphicalMaterialPanel->updateValues(); + + if (_physicalMaterialPanel) + _physicalMaterialPanel->updateValues(); + + if (_styleMaterialPanel) + _styleMaterialPanel->updateValues(); + + if (_displayFurVisualizersPanel) + _displayFurVisualizersPanel->updateValues(); + + if (_lodPanel) + _lodPanel->updateValues(); + + if (_generalAttributePanel) + _generalAttributePanel->updateValues(); + + if (_assetControlPanel) + _assetControlPanel->updateValues(); + + if (_displayMeshMaterialsPanel) + _displayMeshMaterialsPanel->updateValues(); + +#if USE_MATERIAL_SET + if (_materialSetPanel) + _materialSetPanel->updateValues(); +#endif +#else + CoreLib::Inst()->AppMainWindow_updateUI(); +#endif // NV_ARTISTTOOLS + + if (_displayPreferencesPanel) + _displayPreferencesPanel->updateValues(); + + if (_displayScenePanel) + _displayScenePanel->updateValues(); + + if (_displayLightPanel) + _displayLightPanel->updateValues(); + + if (_displayMeshesPanel) + _displayMeshesPanel->updateValues(); + +#if USE_CURVE_EDITOR + if (_curveEditorMainWindow) + UpdateCurveEditor(); +#endif +} + +////////////////////////////////////////////////////////////////////////// +void AppMainWindow::updatePluginUI() +{ + SimpleScene::Inst()->setIsUpdatingUI(true); + +#ifndef NV_ARTISTTOOLS + if (_graphicalMaterialPanel) + _graphicalMaterialPanel->updateValues(); + + if (_physicalMaterialPanel) + _physicalMaterialPanel->updateValues(); + + if (_styleMaterialPanel) + _styleMaterialPanel->updateValues(); + + if (_lodPanel) + _lodPanel->updateValues(); + + if (_displayFurVisualizersPanel) + _displayFurVisualizersPanel->updateValues(); + + if (_generalAttributePanel) + _generalAttributePanel->updateValues(); + + if (_assetControlPanel) + _assetControlPanel->updateValues(); + +#if USE_MATERIAL_SET + if (_materialSetPanel) + _materialSetPanel->updateValues(); +#endif +#else + CoreLib::Inst()->AppMainWindow_updatePluginUI(); +#endif // NV_ARTISTTOOLS + +#if USE_CURVE_EDITOR + if (_curveEditorMainWindow) + UpdateCurveEditor(); +#endif + + SimpleScene::Inst()->setIsUpdatingUI(false); +} + + +////////////////////////////////////////////////////////////////////////// +// event handlers + + +////////////////////////////////////////////////////////////////////////// +// event handlers +bool AppMainWindow::openProject(QString fileName) +{ + if (!fileName.isEmpty()) + { + QFileInfo fileInfo(fileName); + QByteArray dir = QDir::toNativeSeparators(fileInfo.absoluteDir().absolutePath()).toLocal8Bit(); + QByteArray file= fileInfo.fileName().toLocal8Bit(); + + if (SimpleScene::Inst()->LoadProject(dir, file) == false) + { + QMessageBox messageBox; + messageBox.critical(0,"Error","File open error!"); + messageBox.setFixedSize(500,200); + + AppMainWindow::Inst().endProgress(); + char message[1024]; + sprintf(message, "Failed to open project file(\"%s\")", (const char*)file); + viewer_err(message); + return false; + } + + AppMainWindow::Inst().endProgress(); + _lastFilePath = fileInfo.absoluteDir().absolutePath(); + + updateUI(); + return true; + } + return false; +} + +void AppMainWindow::processDragAndDrop(QString fname) +{ + openProject(fname); +} + +void AppMainWindow::removeBookmark(const QString& name) +{ + QList<QAction*> bookmarks = _bookmarkActionGroup->actions(); + int bookmarkCount = bookmarks.size(); + for (int i = 0; i < bookmarkCount; ++i) + { + QAction* act = bookmarks.at(i); + if (act->text() == name) + { + _bookmarkActionGroup->removeAction(act); + _bookmarksMenu->removeAction(act); + delete act; + } + } +} + +void AppMainWindow::renameBookmark(const QString& oldName, const QString& newName) +{ + QList<QAction*> bookmarks = _bookmarkActionGroup->actions(); + int bookmarkCount = bookmarks.size(); + for (int i = 0; i < bookmarkCount; ++i) + { + QAction* act = bookmarks.at(i); + if (act->text() == oldName) + { + act->setText(newName); + } + } +} + +#if USE_CURVE_EDITOR +void AppMainWindow::UpdateCurveEditor() +{ +#ifndef NV_ARTISTTOOLS + _curveEditorMainWindow->setCurveAttributes(SimpleScene::Inst()->GetFurCharacter().GetCurveAttributes()); + _curveEditorMainWindow->setColorCurveAttributes(SimpleScene::Inst()->GetFurCharacter().GetColorAttributes()); +#else + CoreLib::Inst()->AppMainWindow_UpdateCurveEditor(); +#endif // NV_ARTISTTOOLS + + _curveEditorMainWindow->update(); +} + +void AppMainWindow::ShowCurveEditor(int paramId) +{ +#ifndef NV_ARTISTTOOLS + _curveEditorMainWindow->setCurveAttributes(SimpleScene::Inst()->GetFurCharacter().GetCurveAttributes()); + _curveEditorMainWindow->setColorCurveAttributes(SimpleScene::Inst()->GetFurCharacter().GetColorAttributes()); + if (HAIR_PARAMS_ROOT_COLOR == paramId || HAIR_PARAMS_TIP_COLOR == paramId) + { + std::vector<nvidia::CurveEditor::ColorAttribute*> attributes = SimpleScene::Inst()->GetFurCharacter().GetColorAttributesByParamId(paramId); + _curveEditorMainWindow->setSelectedColorAttribute(attributes.size() > 0 ? attributes[0] : nullptr); + } + else + _curveEditorMainWindow->setSelectedCurveAttributes(SimpleScene::Inst()->GetFurCharacter().GetCurveAttributesByParamId(paramId)); + +#else + CoreLib::Inst()->AppMainWindow_ShowCurveEditor(paramId); +#endif // NV_ARTISTTOOLS + + _curveEditorMainWindow->update(); +} +#endif + +void AppMainWindow::menu_clearScene() +{ + SimpleScene::Inst()->Clear(); + updateUI(); +} + +bool AppMainWindow::menu_openfbx() +{ + /* + QString lastDir = _lastFilePath; + QString fileName = QFileDialog::getOpenFileName(this, "Open FBX File", lastDir, "FBX File (*.fbx)"); + if (!fileName.isEmpty()) + { + QFileInfo fileInfo(fileName); + QByteArray dir = QDir::toNativeSeparators(fileInfo.absoluteDir().absolutePath()).toLocal8Bit(); + QByteArray file= fileInfo.fileName().toLocal8Bit(); + + if (SimpleScene::Inst()->LoadSceneFromFbx(dir, file) == false) + { + QMessageBox messageBox; + messageBox.critical(0,"Error","File open error!"); + messageBox.setFixedSize(500,200); + + AppMainWindow::Inst().endProgress(); + + char message[1024]; + sprintf(message, "Failed to open fbx file(\"%s\")", (const char*)file); + viewer_err(message); + + return false; + } + + AppMainWindow::Inst().endProgress(); + + _lastFilePath = fileInfo.absoluteDir().absolutePath(); + + updateUI(); + + return true; + } + return true; + */ + + // dir and file will get in blast open asset dialog + return SimpleScene::Inst()->LoadSceneFromFbx("", ""); +} + +void AppMainWindow::menu_addBookmark() +{ + QString bookmark = SimpleScene::Inst()->createBookmark(); + + QAction* act = new QAction(bookmark, this); + act->setCheckable(true); + _bookmarksMenu->addAction(act); + _bookmarkActionGroup->addAction(act); + act->setChecked(true); +} + +void AppMainWindow::menu_editBookmarks() +{ + CameraBookmarksDialog dlg(this); + dlg.exec(); +} + +void AppMainWindow::menu_bookmarkTriggered(QAction* act) +{ + if (_actionAddBookmark != act && _actionEditBookmarks != act) + { + SimpleScene::Inst()->activateBookmark(act->text()); + } +} + +void AppMainWindow::menu_showOutput() +{ + bool bVisibal = ui.dockOutputWindow->isVisible(); + ui.dockOutputWindow->setVisible(!bVisibal); +} + +void AppMainWindow::menu_showAttributeEditor() +{ + bool bVisibal = ui.dockWidget->isVisible(); + ui.dockWidget->setVisible(!bVisibal); +} +#if USE_CURVE_EDITOR +void AppMainWindow::menu_showCurveEditor() +{ + bool bVisibal = ui.dockWidgetCurveEditor->isVisible(); + ui.dockWidgetCurveEditor->setVisible(!bVisibal); +} +#endif +void AppMainWindow::menu_about() +{ + qDebug("%s", __FUNCTION__); +#ifndef NV_ARTISTTOOLS + AboutDialog::ShowAboutDialog(); +#else + CoreLib::Inst()->AppMainWindow_menu_about(); +#endif // NV_ARTISTTOOLS +} + +void AppMainWindow::menu_opendoc() +{ + qDebug("%s", __FUNCTION__); + +#ifndef NV_ARTISTTOOLS + QString appDir = QApplication::applicationDirPath(); + QString docsFile = QFileInfo(appDir + "/../../docs/User_Guide/Nvidia Blast.chm").absoluteFilePath(); + + QUrl docsUrl = QUrl::fromLocalFile(docsFile); + QUrl url = QUrl::fromUserInput(QString("http://docs.nvidia.com/gameworks/content/artisttools/hairworks/index.html")); + QDesktopServices::openUrl(url); +#else + CoreLib::Inst()->AppMainWindow_menu_opendoc(); +#endif // NV_ARTISTTOOLS +} + +void AppMainWindow::shortcut_frameall() +{ + qDebug("ShortCut_F: frame all"); +} + +void AppMainWindow::shortcut_hud() +{ + Gamepad::ShowHideHud(); + qDebug("ShortCut_S: statistics on/off"); +} + +void AppMainWindow::shortcut_statistics() +{ + Gamepad::ShowHideStats(); + qDebug("ShortCut_S: statistics on/off"); +} + +void AppMainWindow::shortcut_reset() +{ + Gamepad::ResetAnimation(); +} + +void AppMainWindow::shortcut_pause() +{ + //_mainToolbar->on_btnPlayAnimation_clicked(); // this one has some delay + //qDebug("ShortCut_Space: play/pause simualtion"); + Gamepad::PlayPauseAnimation(); +} + +bool AppMainWindow::IsExpertMode() +{ + return _expertMode; +} + +void AppMainWindow::demo_next() +{ + Gamepad::DemoNext(); +} + +void AppMainWindow::demo_prev() +{ + Gamepad::DemoPrev(); +} + +void AppMainWindow::shortcut_escape() +{ + Gamepad::DemoEscape(); +} + +void AppMainWindow::shortcut_expert() +{ + qDebug("ShortCut_F: expert mode on/off"); + + _expertMode = !_expertMode; + bool mode = !_expertMode; + + ui.menuBar->setVisible(mode); + ui.dockWidget->setVisible(mode); + ui.dockOutputWindow->setVisible(mode); +#if USE_CURVE_EDITOR + ui.dockWidgetCurveEditor->setVisible(mode); +#endif + ui.statusBar->setVisible(mode); + +#ifndef NV_ARTISTTOOLS + if (_mainToolbar) + _mainToolbar->setVisible(mode); +#else + CoreLib::Inst()->AppMainWindow_shortcut_expert(mode); +#endif // NV_ARTISTTOOLS + + //bool bDemoMode = AppMainWindow::IsExpertMode(); + bool bMaxSized = AppMainWindow::Inst().isMaximized(); + if (!bMaxSized) + { + // resize before change to demo mode + AppMainWindow::Inst().showMaximized(); + } + + _d3dWidget->update(); + Gamepad::ShowProjectName(); +} + +void AppMainWindow::shortcut_output() +{ + ui.dockOutputWindow->show(); + _d3dWidget->update(); +} + +void AppMainWindow::shortcut_meshmat() +{ +} + +void AppMainWindow::shortcut_fitcamera() +{ + qDebug("ShortCut_Ctrl+F: fit camera"); + SimpleScene::Inst()->FitCamera(); +} + +#if USE_CURVE_EDITOR +void AppMainWindow::onCurveAttributeChanged(nvidia::CurveEditor::CurveAttribute* attribute) +{ +#ifndef NV_ARTISTTOOLS + SimpleScene::Inst()->GetFurCharacter().updateCurveAttribute(attribute); +#else + CoreLib::Inst()->AppMainWindow_onCurveAttributeChanged(attribute); +#endif // NV_ARTISTTOOLS +} + +void AppMainWindow::onColorAttributeChanged(nvidia::CurveEditor::ColorAttribute* attribute) +{ +#ifndef NV_ARTISTTOOLS + SimpleScene::Inst()->GetFurCharacter().updateColorAttribute(attribute); + _graphicalMaterialPanel->updateValues(); +#else + CoreLib::Inst()->AppMainWindow_onColorAttributeChanged(attribute); +#endif // NV_ARTISTTOOLS +} + +void AppMainWindow::onReloadColorAttributeTexture(nvidia::CurveEditor::ColorAttribute* attribute, bool reloadColorTex, int selectedCtrlPntIndex) +{ +#ifndef NV_ARTISTTOOLS + SimpleScene::Inst()->GetFurCharacter().reloadColorAttributeTexture(attribute, reloadColorTex, selectedCtrlPntIndex); +#else + CoreLib::Inst()->AppMainWindow_onReloadColorAttributeTexture(attribute, reloadColorTex, selectedCtrlPntIndex); +#endif // NV_ARTISTTOOLS +} +#endif + +/* + Maya Scheme: + ALT + LMB -> Rotate + ALT + MMB -> Pan + ALT + RMB -> Zoom + + M-wheel -> Zoom + + 3dsMax Scheme: + ALT + MMB -> Rotate + N/A + MMB -> Pan + ALT + SHFT + MMB -> Zoom + + M-wheel -> Zoom +*/ + +void AppMainWindow::InitMouseSchemes() +{ + ShortCut alt_lmb = qMakePair(Qt::KeyboardModifiers(Qt::AltModifier), Qt::MouseButtons(Qt::LeftButton)); + ShortCut alt_mmb = qMakePair(Qt::KeyboardModifiers(Qt::AltModifier), Qt::MouseButtons(Qt::MiddleButton)); + ShortCut alt_rmb = qMakePair(Qt::KeyboardModifiers(Qt::AltModifier), Qt::MouseButtons(Qt::RightButton)); + ShortCut non_mmb = qMakePair(Qt::KeyboardModifiers(Qt::NoModifier), Qt::MouseButtons(Qt::MiddleButton)); + ShortCut alt_shft_mmb = qMakePair(Qt::KeyboardModifiers(Qt::AltModifier|Qt::ShiftModifier), Qt::MouseButtons(Qt::MiddleButton)); + + _mayaScheme[alt_lmb] = 'R'; + _mayaScheme[alt_mmb] = 'P'; + _mayaScheme[alt_rmb] = 'Z'; + + _maxScheme[alt_mmb] = 'R'; + _maxScheme[non_mmb] = 'P'; + _maxScheme[alt_shft_mmb] = 'Z'; +} + +char AppMainWindow::TestMouseScheme( Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons ) +{ + char op = TestDragCamera(modifiers, buttons); + + if (op != 0) + return op; + + if (modifiers == Qt::KeyboardModifier(Qt::ControlModifier)) + { + if (buttons == Qt::MouseButton(Qt::LeftButton)) + return 'L'; + else if (buttons == Qt::MouseButton(Qt::MiddleButton)) + return 'K'; + } + + if (modifiers == Qt::KeyboardModifier(Qt::ShiftModifier)) + return 'W'; + + return 0; +} + +char AppMainWindow::TestDragCamera( Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons ) +{ + if(modifiers != Qt::NoModifier && modifiers != Qt::AltModifier) return 0; + + ShortCut input = qMakePair(modifiers, buttons); + + int scheme = _navigationStyle; + + // !! MUST MATCH THE ORDER OF ITEMS IN 'cbNavigationStyle' + const int MAYA_SCHEME = 0; + const int MAX_SCHEME = 1; + if(scheme == MAYA_SCHEME) + { + auto itr = _mayaScheme.find(input); + if(itr != _mayaScheme.end()) return itr.value(); + } + else + { + auto itr = _maxScheme.find(input); + if(itr != _maxScheme.end()) return itr.value(); + } + return 0; +} + +QString AppMainWindow::OpenTextureFile(QString title) +{ + QString lastDir = _lastFilePath; + QString titleStr = "Open Texture File"; + if(!title.isEmpty()) + titleStr = title; + + QString fileName = QFileDialog::getOpenFileName(this, titleStr, lastDir, "Images (*.dds *.png *.bmp *.jpg *.tga)"); + if(!fileName.isEmpty()) + { + QFileInfo fileInfo(fileName); + _lastFilePath = fileInfo.absoluteDir().absolutePath(); + } + + return fileName; +} + +void AppMainWindow::closeEvent (QCloseEvent *event) +{ + ViewerOutput::Inst().UnRegisterPrinter(_printer); + + if (1) + { +#if USE_CURVE_EDITOR + _curveEditorMainWindow->setParent(NULL); +#endif + event->accept(); + emit aboutToQuit(); + return; + } + if (SimpleScene::Inst()->IsProjectModified() || SimpleScene::Inst()->IsFurModified()) + { + QMessageBox::StandardButton resBtn = QMessageBox::warning( + this, tr("Blast Viewer"), + tr("Save changes?\n"), + QMessageBox::Cancel | QMessageBox::No | QMessageBox::Yes, + QMessageBox::Yes); + switch (resBtn) + { + case QMessageBox::Yes: +#ifndef NV_ARTISTTOOLS + if (!menu_saveHair()) + { + event->ignore(); + return; + } + if (!menu_saveProject()) + { + event->ignore(); + return; + } +#else + if (!CoreLib::Inst()->AppMainWindow_closeEvent(event)) + { + event->ignore(); + return; + } +#endif // NV_ARTISTTOOLS + break; + case QMessageBox::No: + break; + default: + event->ignore(); + return; + } + } + event->accept(); + emit aboutToQuit(); +} + +void AppMainWindow::updateMainToolbar() +{ +#ifndef NV_ARTISTTOOLS + if (_mainToolbar) + _mainToolbar->updateValues(); +#else + CoreLib::Inst()->AppMainWindow_updateMainToolbar(); +#endif // NV_ARTISTTOOLS +} + +#ifndef NV_ARTISTTOOLS +bool AppMainWindow::menu_openProject() +{ + QString lastDir = _lastFilePath; + QString fileName = QFileDialog::getOpenFileName(this, "Open Hair Project File", lastDir, "Hair Project File (*.furproj)"); + + return openProject(fileName); +} + +bool AppMainWindow::menu_saveProject() +{ + char message[1024]; + + std::string projectFilePath = GlobalSettings::Inst().getAbsoluteFilePath(); + if (projectFilePath != "") + { + if (SimpleScene::Inst()->SaveProject( + GlobalSettings::Inst().m_projectFileDir.c_str(), + GlobalSettings::Inst().m_projectFileName.c_str() + ) == false) + { + QMessageBox messageBox; + + sprintf(message, "Project file %s could not be saved!", (const char*)projectFilePath.c_str()); + messageBox.critical(0, "Error", message); + messageBox.setFixedSize(500, 200); + char message[1024]; + sprintf(message, "Failed to save project file(\"%s\")", (const char*)projectFilePath.c_str()); + viewer_err(message); + return false; + } + + sprintf(message, "Project file %s was saved.", (const char*)projectFilePath.c_str()); + + /* + QMessageBox messageBox; + messageBox.information(0, "Info", message); + messageBox.setFixedSize(500,200); + */ + viewer_msg(message); + return true; + } + else + { + return menu_saveProjectAs(); + } + return false; +} + +bool AppMainWindow::menu_saveProjectAs() +{ + char message[1024]; + + QString lastDir = _lastFilePath; + QString fileName = QFileDialog::getSaveFileName(this, "Save Hair Project File", lastDir, "Hair Project File (*.furproj)"); + if (!fileName.isEmpty()) + { + QFileInfo fileInfo(fileName); + QByteArray dir = QDir::toNativeSeparators(fileInfo.absoluteDir().absolutePath()).toLocal8Bit(); + QByteArray file = fileInfo.fileName().toLocal8Bit(); + + if (SimpleScene::Inst()->SaveProject(dir, file) == false) + { + QMessageBox messageBox; + sprintf(message, "Project file %s could not be saved!", (const char*)file); + messageBox.critical(0, "Error", message); + messageBox.setFixedSize(500, 200); + return false; + } + + sprintf(message, "Project file %s was saved.", (const char*)file); + + /* + QMessageBox messageBox; + messageBox.information(0, "Info", message); + messageBox.setFixedSize(500,200); + */ + + viewer_msg(message); + + _lastFilePath = fileInfo.absoluteDir().absolutePath(); + return true; + } + return false; +} + +bool AppMainWindow::menu_openHair() +{ + AppMainWindow& window = AppMainWindow::Inst(); + QString lastDir = window._lastFilePath; + QString fileName = QFileDialog::getOpenFileName(&window, "Open Hair File", lastDir, "Apex Hair File (*.apx;*.apb)"); + if (!fileName.isEmpty()) + { + QFileInfo fileInfo(fileName); + QByteArray dir = QDir::toNativeSeparators(fileInfo.absoluteDir().absolutePath()).toLocal8Bit(); + QByteArray file = fileInfo.fileName().toLocal8Bit(); + + if (SimpleScene::Inst()->GetFurCharacter().LoadHairAsset(dir, file) == false) + { + QMessageBox messageBox; + messageBox.critical(0, "Error", "File open error!"); + messageBox.setFixedSize(500, 200); + char message[1024]; + sprintf(message, "Failed to open hair file(\"%s\")", (const char*)file); + viewer_err(message); + return false; + } + + window._lastFilePath = fileInfo.absoluteDir().absolutePath(); + + window.updateUI(); + return true; + } + + return false; +} + +////////////////////////////////////////////////////////////////////////// +// event handlers +bool AppMainWindow::menu_importHair() +{ + AppMainWindow& window = AppMainWindow::Inst(); + QString lastDir = window._lastFilePath; + QString fileName = QFileDialog::getOpenFileName(&window, "Import Hair File", lastDir, "Apex Hair File (*.apx;*.apb)"); + if (!fileName.isEmpty()) + { + QFileInfo fileInfo(fileName); + QByteArray dir = QDir::toNativeSeparators(fileInfo.absoluteDir().absolutePath()).toLocal8Bit(); + QByteArray file = fileInfo.fileName().toLocal8Bit(); + + if (SimpleScene::Inst()->GetFurCharacter().ImportSelectedHairAsset(dir, file) == false) + { + QMessageBox messageBox; + messageBox.critical(0, "Error", "File open error!"); + messageBox.setFixedSize(500, 200); + char message[1024]; + sprintf(message, "Failed to import hair file(\"%s\")", (const char*)file); + viewer_err(message); + return false; + } + + window._lastFilePath = fileInfo.absoluteDir().absolutePath(); + + window.updateUI(); + return true; + } + return false; +} + + +bool AppMainWindow::menu_saveHair() +{ + return SimpleScene::Inst()->GetFurCharacter().SaveHairAsset(); +} + +bool AppMainWindow::menu_saveHairAs() +{ + AppMainWindow& window = AppMainWindow::Inst(); + QString lastDir = window._lastFilePath; + QString fileName = QFileDialog::getSaveFileName(&window, "Save as", lastDir, "Apex Hair File (*.apx;*.apb)"); + if (!fileName.isEmpty()) + { + QFileInfo fileInfo(fileName); + QByteArray dir = QDir::toNativeSeparators(fileInfo.absoluteDir().absolutePath()).toLocal8Bit(); + QByteArray file = fileInfo.fileName().toLocal8Bit(); + + if (SimpleScene::Inst()->GetFurCharacter().SaveHairAssetAs(dir, file)) + { + window.updateUI(); + } + + window._lastFilePath = fileInfo.absoluteDir().absolutePath(); + return true; + } + return false; +} + +bool AppMainWindow::menu_saveAllHairs() +{ + return SimpleScene::Inst()->GetFurCharacter().SaveAllHairs(); +} +#endif // NV_ARTISTTOOLS
\ No newline at end of file diff --git a/tools/ArtistTools/source/CoreLib/Window/AppMainWindow.h b/tools/ArtistTools/source/CoreLib/Window/AppMainWindow.h new file mode 100644 index 0000000..4183fc2 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/AppMainWindow.h @@ -0,0 +1,208 @@ +#ifndef APPMAINWINDOW_H +#define APPMAINWINDOW_H + +#include <QtWidgets/QMainWindow> +#include <QtWidgets/QProgressDialog> + +#include "ui_AppMainWindow.h" +#include "UIGlobal.h" + +class StyleMaterialPanel; +class AssetControlPanel; +class PhysicalMaterialPanel; +class GraphicalMaterialPanel; +class DisplayFurVisualizersPanel; +class GeneralAttributePanel; +class BlastToolbar; +class LodPanel; +class DisplayMeshesPanel; +class DisplayPreferencesPanel; +class DisplayScenePanel; +class DisplayLightPanel; +class DisplayMeshMaterialsPanel; + +#if USE_CURVE_EDITOR +namespace nvidia { +namespace CurveEditor { + +class CurveEditorMainWindow; +class CurveAttribute; +class ColorAttribute; + +} // namespace CurveEditor +} // namespace nvidia +#endif + +#if USE_MATERIAL_SET +class MaterialSetPanel; +#endif + +class D3DWidget; +class MsgPrinter; +class AppMainWindow : public QMainWindow +{ + Q_OBJECT + +public: + AppMainWindow(QWidget *parent = 0, Qt::WindowFlags flags = 0); + ~AppMainWindow(); + + CORELIB_EXPORT static AppMainWindow& Inst(); + + CORELIB_EXPORT void InitUI(); + CORELIB_EXPORT void updateUI(); + CORELIB_EXPORT void updatePluginUI(); + + static bool IsExpertMode(); + + D3DWidget* GetRenderWidget() {return _d3dWidget;} + char TestMouseScheme(Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons); + + CORELIB_EXPORT QString OpenTextureFile(QString title = ""); + + void setNavigationStyle(int index) { _navigationStyle = index; } + int getNavigationStyle() { return _navigationStyle; } + + void closeEvent (QCloseEvent *event); + + CORELIB_EXPORT void startProgress(); + CORELIB_EXPORT void setProgressMaximum(int m); + CORELIB_EXPORT void setProgress(const char* label, int progress = -1); + CORELIB_EXPORT void endProgress(); + CORELIB_EXPORT void quit(); + + CORELIB_EXPORT void updateMainToolbar(); + CORELIB_EXPORT void processDragAndDrop(QString fname); + CORELIB_EXPORT bool openProject(QString fileName); + + CORELIB_EXPORT static void setConnectionMode(int); + + DisplayMeshesPanel* GetDisplayMeshesPanel() { return _displayMeshesPanel; } + DisplayPreferencesPanel* GetDisplayPreferencesPanel() { return _displayPreferencesPanel; } + DisplayScenePanel* GetDisplayScenePanel() { return _displayScenePanel; } + DisplayLightPanel* GetDisplayLightPanel() { return _displayLightPanel; } + + void removeBookmark(const QString& name); + void renameBookmark(const QString& oldName, const QString& newName); + +#if USE_CURVE_EDITOR + CORELIB_EXPORT nvidia::CurveEditor::CurveEditorMainWindow* GetCurveEditorMainWindow() { return _curveEditorMainWindow; } + CORELIB_EXPORT void UpdateCurveEditor(); + CORELIB_EXPORT void ShowCurveEditor(int paramId); +#endif + + inline QString GetFilePath() { return _lastFilePath; } +signals: + void aboutToQuit(); + + public slots: + CORELIB_EXPORT void menu_clearScene(); + CORELIB_EXPORT bool menu_openfbx(); + CORELIB_EXPORT void menu_addBookmark(); + CORELIB_EXPORT void menu_editBookmarks(); + CORELIB_EXPORT void menu_bookmarkTriggered(QAction* act); + CORELIB_EXPORT void menu_showOutput(); + CORELIB_EXPORT void menu_showAttributeEditor(); + CORELIB_EXPORT void menu_about(); + CORELIB_EXPORT void menu_opendoc(); + CORELIB_EXPORT void shortcut_frameall(); + CORELIB_EXPORT void shortcut_hud(); + CORELIB_EXPORT void shortcut_statistics(); + CORELIB_EXPORT void shortcut_pause(); + CORELIB_EXPORT void shortcut_reset(); + CORELIB_EXPORT void shortcut_escape(); + CORELIB_EXPORT void shortcut_expert(); + CORELIB_EXPORT void demo_next(); + CORELIB_EXPORT void demo_prev(); + CORELIB_EXPORT void shortcut_output(); + CORELIB_EXPORT void shortcut_meshmat(); + CORELIB_EXPORT void shortcut_fitcamera(); + +#if USE_CURVE_EDITOR + CORELIB_EXPORT void menu_showCurveEditor(); + CORELIB_EXPORT void onCurveAttributeChanged(nvidia::CurveEditor::CurveAttribute* attribute); + CORELIB_EXPORT void onColorAttributeChanged(nvidia::CurveEditor::ColorAttribute* attribute); + CORELIB_EXPORT void onReloadColorAttributeTexture(nvidia::CurveEditor::ColorAttribute* attribute, bool reloadColorTex, int selectedCtrlPntIndex); +#endif + +private: + char TestDragCamera(Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons); + +public: + void InitMenuItems(); + void InitToolbar(); + void InitPluginTab(); + void InitMainTab(); + void InitMouseSchemes(); + void InitShortCuts(); + void updateBookmarkMenu(); + + Ui::AppMainWindowClass ui; + + D3DWidget* _d3dWidget; + QMenu* _bookmarksMenu; + + DisplayMeshesPanel* _displayMeshesPanel; + DisplayPreferencesPanel* _displayPreferencesPanel; + DisplayScenePanel* _displayScenePanel; + DisplayLightPanel* _displayLightPanel; + + +#if USE_CURVE_EDITOR + bool _curveEditorInitizlized; + nvidia::CurveEditor::CurveEditorMainWindow* _curveEditorMainWindow; +#endif + + typedef QPair<Qt::KeyboardModifiers, Qt::MouseButtons> ShortCut; + QMap<ShortCut, char> _mayaScheme; + QMap<ShortCut, char> _maxScheme; + QActionGroup* _bookmarkActionGroup; + QAction* _actionAddBookmark; + QAction* _actionEditBookmarks; + + QString _lastFilePath; + + int _navigationStyle; + + MsgPrinter* _printer; + + QProgressDialog _progressDialog; + + + static bool _expertMode; + + CORELIB_EXPORT static int _connectionMode; + +#ifndef NV_ARTISTTOOLS + BlastToolbar* GetMainToolbar() { return _mainToolbar; } + DisplayFurVisualizersPanel* GetFurVisualizersPanel() { return _displayFurVisualizersPanel; } + +public slots: + bool menu_openProject(); + bool menu_saveProject(); + bool menu_saveProjectAs(); + bool menu_openHair(); + bool menu_importHair(); + bool menu_saveHair(); + bool menu_saveHairAs(); + bool menu_saveAllHairs(); + +private: + BlastToolbar* _mainToolbar; + AssetControlPanel* _assetControlPanel; + GeneralAttributePanel* _generalAttributePanel; + DisplayFurVisualizersPanel* _displayFurVisualizersPanel; + StyleMaterialPanel* _styleMaterialPanel; + PhysicalMaterialPanel* _physicalMaterialPanel; + GraphicalMaterialPanel* _graphicalMaterialPanel; + LodPanel* _lodPanel; + DisplayMeshMaterialsPanel* _displayMeshMaterialsPanel; +#if USE_MATERIAL_SET + MaterialSetPanel* _materialSetPanel; +#endif +#endif // NV_ARTISTTOOLS + + bool m_bGizmoWithLocal; +}; + +#endif // APPMAINWINDOW_H diff --git a/tools/ArtistTools/source/CoreLib/Window/CameraBookmarksDialog.cpp b/tools/ArtistTools/source/CoreLib/Window/CameraBookmarksDialog.cpp new file mode 100644 index 0000000..445067a --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/CameraBookmarksDialog.cpp @@ -0,0 +1,106 @@ +#include "CameraBookmarksDialog.h" +#include "SimpleScene.h" +#include "AppMainWindow.h" +#include <QtWidgets/QMessageBox> + +CameraBookmarksDialog::CameraBookmarksDialog(QWidget *parent) + : QDialog(parent) +{ + ui.setupUi(this); + + ui.buttonBox->button(QDialogButtonBox::Ok)->setFixedWidth(64); + ui.buttonBox->button(QDialogButtonBox::Cancel)->setFixedWidth(64); + ui.buttonBox->button(QDialogButtonBox::Ok)->setFixedHeight(23); + ui.buttonBox->button(QDialogButtonBox::Cancel)->setFixedHeight(23); + setWindowFlags(windowFlags()&~Qt::WindowContextHelpButtonHint); + + QObject::connect(ui.buttonBox->button(QDialogButtonBox::Ok), SIGNAL(clicked()), this, SLOT(accept())); + QObject::connect(ui.buttonBox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), this, SLOT(reject())); + + ui.editBookmarkName->setEnabled(false); + ui.btnRename->setEnabled(false); + ui.btnDelete->setEnabled(false); + + _fillListWidget(); +} + +CameraBookmarksDialog::~CameraBookmarksDialog() +{ + +} + +void CameraBookmarksDialog::on_listWidgetBookmarks_itemSelectionChanged() +{ + if (ui.listWidgetBookmarks->selectedItems().size() == 0) + { + ui.editBookmarkName->setEnabled(false); + ui.btnRename->setEnabled(false); + ui.btnDelete->setEnabled(false); + } + else + { + QListWidgetItem* item = ui.listWidgetBookmarks->selectedItems().at(0); + ui.editBookmarkName->setEnabled(true); + ui.btnRename->setEnabled(true); + ui.btnDelete->setEnabled(true); + + ui.editBookmarkName->setText(item->text()); + } +} + +void CameraBookmarksDialog::on_editBookmarkName_textChanged(QString val) +{ + +} + +void CameraBookmarksDialog::on_btnRename_clicked() +{ + if (ui.editBookmarkName->text().isEmpty()) + { + QListWidgetItem* item = ui.listWidgetBookmarks->selectedItems().at(0); + ui.editBookmarkName->setText(item->text()); + } + else + { + if (_isNameConflict(ui.editBookmarkName->text())) + { + QMessageBox::warning(this, tr("Warning"), tr("The new name is conflict with name of other camera bookmark!")); + return; + } + + QListWidgetItem* item = ui.listWidgetBookmarks->selectedItems().at(0); + SimpleScene::Inst()->renameBookmark(item->text(), ui.editBookmarkName->text()); + AppMainWindow::Inst().renameBookmark(item->text(), ui.editBookmarkName->text()); + item->setText(ui.editBookmarkName->text()); + } + +} + +void CameraBookmarksDialog::on_btnDelete_clicked() +{ + QListWidgetItem* item = ui.listWidgetBookmarks->selectedItems().at(0); + SimpleScene::Inst()->removeBookmark(item->text()); + AppMainWindow::Inst().removeBookmark(item->text()); + ui.listWidgetBookmarks->takeItem(ui.listWidgetBookmarks->row(item)); + delete item; + +} + +void CameraBookmarksDialog::_fillListWidget() +{ + QList<QString> bookmarks = SimpleScene::Inst()->getBookmarkNames(); + ui.listWidgetBookmarks->addItems(bookmarks); +} + +bool CameraBookmarksDialog::_isNameConflict(const QString& name) +{ + QList<QString> bookmarks = SimpleScene::Inst()->getBookmarkNames(); + int bookmarkCount = bookmarks.size(); + for (int i = 0; i < bookmarkCount; ++i) + { + if (bookmarks.at(i) == name) + return true; + } + + return false; +}
\ No newline at end of file diff --git a/tools/ArtistTools/source/CoreLib/Window/CameraBookmarksDialog.h b/tools/ArtistTools/source/CoreLib/Window/CameraBookmarksDialog.h new file mode 100644 index 0000000..13caa42 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/CameraBookmarksDialog.h @@ -0,0 +1,31 @@ +#ifndef CAMERABOOKMARKSDIALOG_H +#define CAMERABOOKMARKSDIALOG_H + +#include <QtWidgets/QDialog> +#include "ui_CameraBookmarksDialog.h" + +#include "corelib_global.h" + +class CameraBookmarksDialog : public QDialog +{ + Q_OBJECT + +public: + CameraBookmarksDialog(QWidget *parent = 0); + ~CameraBookmarksDialog(); + +private slots: +CORELIB_EXPORT void on_listWidgetBookmarks_itemSelectionChanged(); +CORELIB_EXPORT void on_editBookmarkName_textChanged(QString val); +CORELIB_EXPORT void on_btnRename_clicked(); +CORELIB_EXPORT void on_btnDelete_clicked(); + +private: + void _fillListWidget(); + bool _isNameConflict(const QString& name); + +private: + Ui::CameraBookmarksDialog ui; +}; + +#endif // CAMERABOOKMARKSDIALOG_H diff --git a/tools/ArtistTools/source/CoreLib/Window/D3DWidget.cpp b/tools/ArtistTools/source/CoreLib/Window/D3DWidget.cpp new file mode 100644 index 0000000..69be706 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/D3DWidget.cpp @@ -0,0 +1,151 @@ +#include <QtGui/QResizeEvent> +#include <QtGui/QMouseEvent> +#include <QtCore/QTimer> +#include <QtCore/QMimeData> + +#include "D3DWidget.h" +#include "AppMainWindow.h" +#include "SimpleScene.h" + +D3DWidget::D3DWidget( QWidget* parent ) + : QWidget(parent, Qt::MSWindowsOwnDC) // Same settings as used in Qt's QGLWidget +{ + // same settings as used in QGLWidget to avoid 'white flickering' + setAttribute(Qt::WA_PaintOnScreen); + setAttribute(Qt::WA_NoSystemBackground); + + // to get rid of 'black flickering' + setAttribute(Qt::WA_OpaquePaintEvent, true); + + QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); + sizePolicy.setHorizontalStretch(0); + sizePolicy.setVerticalStretch(0); + setSizePolicy(sizePolicy); + + _appWindow = qobject_cast<AppMainWindow*>(parent); + this->setAcceptDrops(true); + + setMouseTracking(true); +} + +void D3DWidget::dragEnterEvent(QDragEnterEvent *e) +{ + CoreLib::Inst()->D3DWidget_dragEnterEvent(e); + e->acceptProposedAction(); +} + +void D3DWidget::dragMoveEvent(QDragMoveEvent *e) +{ + CoreLib::Inst()->D3DWidget_dragMoveEvent(e); + e->acceptProposedAction(); +} + +void D3DWidget::dragLeaveEvent(QDragLeaveEvent *e) +{ + CoreLib::Inst()->D3DWidget_dragLeaveEvent(e); + //e->acceptProposedAction(); +} + +void D3DWidget::dropEvent(QDropEvent *e) +{ + CoreLib::Inst()->D3DWidget_dropEvent(e); + + const QMimeData* data = e->mimeData(); + QString name = data->objectName(); + + bool hasUrls = data->hasUrls(); + if (!hasUrls) + return; + + QList<QUrl> urlList = data->urls(); + QString text; + for (int i = 0; i < urlList.size() && i < 32; ++i) { + QString url = urlList.at(i).toLocalFile(); + text += url; + } + + e->acceptProposedAction(); + + AppMainWindow::Inst().processDragAndDrop(text); +} + +void D3DWidget::paintEvent( QPaintEvent* e ) +{ + CoreLib::Inst()->D3DWidget_paintEvent(e); + + SimpleScene::Inst()->Draw(); +} + +void D3DWidget::Shutdown() +{ + SimpleScene::Inst()->Shutdown(); +} + +void D3DWidget::Timeout() +{ + SimpleScene::Inst()->Timeout(); +} + +void D3DWidget::resizeEvent( QResizeEvent* e ) +{ + int w = e->size().width(); + int h = e->size().height(); + // resize calls D3D11RenderWindow::Resize + SimpleScene::Inst()->Resize(w,h); + // D3DWidget_resizeEvent calls resize in DeviceManager + CoreLib::Inst()->D3DWidget_resizeEvent(e); +} + +void D3DWidget::mouseMoveEvent( QMouseEvent* e ) +{ + CoreLib::Inst()->D3DWidget_mouseMoveEvent(e); + + atcore_float2 pos = gfsdk_makeFloat2(e->x(), e->y()); + SimpleScene::Inst()->onMouseMove(pos); + + Q_ASSERT(_appWindow != NV_NULL); + char mode = _appWindow->TestMouseScheme(e->modifiers(), e->buttons()); + + if(mode == 0) return; + SimpleScene::Inst()->Drag(mode); +} + +void D3DWidget::wheelEvent(QWheelEvent* e) +{ + CoreLib::Inst()->D3DWidget_wheelEvent(e); + + SimpleScene::Inst()->onMouseWheel(e->delta()); + SimpleScene::Inst()->WheelZoom(); +} + +void D3DWidget::mousePressEvent( QMouseEvent* e ) +{ + CoreLib::Inst()->D3DWidget_mousePressEvent(e); + + atcore_float2 pos = gfsdk_makeFloat2(e->x(), e->y()); + SimpleScene::Inst()->onMouseDown(pos); +} + +void D3DWidget::mouseReleaseEvent( QMouseEvent* e ) +{ + CoreLib::Inst()->D3DWidget_mouseReleaseEvent(e); + + atcore_float2 pos = gfsdk_makeFloat2(e->x(), e->y()); + SimpleScene::Inst()->onMouseUp(pos); +} + +void D3DWidget::keyPressEvent( QKeyEvent* e ) +{ + CoreLib::Inst()->D3DWidget_keyPressEvent(e); +} + +void D3DWidget::keyReleaseEvent( QKeyEvent* e ) +{ + CoreLib::Inst()->D3DWidget_keyReleaseEvent(e); +} + +void D3DWidget::contextMenuEvent(QContextMenuEvent *e) +{ + CoreLib::Inst()->D3DWidget_contextMenuEvent(e); +} + diff --git a/tools/ArtistTools/source/CoreLib/Window/D3DWidget.h b/tools/ArtistTools/source/CoreLib/Window/D3DWidget.h new file mode 100644 index 0000000..0de9a1e --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/D3DWidget.h @@ -0,0 +1,51 @@ +#ifndef D3DWidget_h__ +#define D3DWidget_h__ + +#include <QtWidgets/QWidget> +#include "Nv.h" + +#include "corelib_global.h" + +class AppMainWindow; +class D3DWidget : public QWidget +{ + Q_OBJECT + +public: + + D3DWidget(QWidget* parent); + virtual ~D3DWidget(){} + +signals: + void DropSignal(); + +public slots: +CORELIB_EXPORT void Timeout(); +CORELIB_EXPORT void Shutdown(); + +protected: + // return NULL to ignore system painter + virtual QPaintEngine *paintEngine() const { return NV_NULL; } + + // QWidget events + virtual void resizeEvent(QResizeEvent* e); + virtual void paintEvent(QPaintEvent* e); + virtual void mousePressEvent(QMouseEvent* e); + virtual void mouseReleaseEvent(QMouseEvent* e); + virtual void mouseMoveEvent(QMouseEvent* e); + virtual void wheelEvent ( QWheelEvent * e); + virtual void keyPressEvent(QKeyEvent* e); + virtual void keyReleaseEvent(QKeyEvent* e); + + virtual void dragEnterEvent(QDragEnterEvent *e); + virtual void dragMoveEvent(QDragMoveEvent *e); + virtual void dragLeaveEvent(QDragLeaveEvent *e); + virtual void dropEvent(QDropEvent *e); + + virtual void contextMenuEvent(QContextMenuEvent *e); + +private: + AppMainWindow* _appWindow; +}; + +#endif // D3DWidget_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayLightPanel.cpp b/tools/ArtistTools/source/CoreLib/Window/DisplayLightPanel.cpp new file mode 100644 index 0000000..ec267a3 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayLightPanel.cpp @@ -0,0 +1,263 @@ +#include "AppMainWindow.h" +#include "DisplayLightPanel.h" + +#include "Light.h" +#include "GlobalSettings.h" + +#include <QtWidgets/QColorDialog> +#include <QtCore/QFileInfo> + +DisplayLightPanel::DisplayLightPanel(QWidget* parent) + : + QWidget(parent) +{ + ui.setupUi(this); + _isUpdatingUI = false; + + ConfigSpinBox<SlideSpinBoxF>(ui.spinLightDistance, 0.0, 1000.0, 0.1); + ConfigSpinBox<SlideSpinBoxF>(ui.spinLightIntensity, 0.0, 5.0, 0.01); + + ui.btnLightColorTex->setIcon(QIcon(":/AppMainWindow/images/TextureEnabled_icon.png")); + ui.btnLightColorTex->setIconSize(QSize(12,12)); + ui.btnLightColorTexReload->setIcon(QIcon(":/AppMainWindow/images/Refresh_icon.png")); + ui.btnLightColorTexClear->setIcon(QIcon(":/AppMainWindow/images/Remove_icon.png")); + + connect(ui.listSelectedLight, SIGNAL(itemSelectionChanged()), this, SLOT(onListSelectionChanged())); +} + +void DisplayLightPanel::onListSelectionChanged() +{ + if (_isUpdatingUI) + return; + + int numSelected = ui.listSelectedLight->selectedItems().count(); + + // change selection only when there is something selected + if (numSelected > 0) + { + int numItems = ui.listSelectedLight->count(); + { + for (int i = 0; i < numItems; i++) + { + bool selected = ui.listSelectedLight->item(i)->isSelected(); + Light::GetLight(i)->m_selected = selected; + } + } + } + + updateUI(); +} + +void DisplayLightPanel::on_cbShadowMapResolution_currentIndexChanged( int index ) +{ + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight || !pLight->m_selected) + continue; + + pLight->SetShadowMapResolution(index); + } +} + +void DisplayLightPanel::on_btnLightUseShadow_stateChanged(int state) +{ + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight || !pLight->m_selected) + continue; + + pLight->m_useShadows = state; + } +} + +void DisplayLightPanel::on_btnVisualizeLight_stateChanged(int state) +{ + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight || !pLight->m_selected) + continue; + + pLight->m_visualize = state; + } +} + +void DisplayLightPanel::on_btnLightEnable_stateChanged(int state) +{ + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight || !pLight->m_selected) + continue; + + pLight->m_enable = state; + } +} + +void DisplayLightPanel::on_btnLinkLightEnable_stateChanged(int state) +{ + Light::SetLinkLightOption(state != 0 ? true : false); +} + +void DisplayLightPanel::on_spinLightDistance_valueChanged(double v) +{ + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight || !pLight->m_selected) + continue; + + pLight->SetDistance(v); + } +} + +void DisplayLightPanel::on_spinLightIntensity_valueChanged(double v) +{ + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight || !pLight->m_selected) + continue; + + pLight->m_intensity = v; + } +} + +void DisplayLightPanel::on_btnVisualizeShadowMap_stateChanged(int state) +{ + GlobalSettings::Inst().m_visualizeShadowMap = state; +} + +void DisplayLightPanel::setButtonColor(QPushButton *button, float r, float g, float b) +{ + QColor specColor; + specColor.setRgbF(r,g,b); + QString specBtnStyle = QString("background-color: rgb(%1,%2,%3);") + .arg(specColor.red()) + .arg(specColor.green()) + .arg(specColor.blue()); + button->setStyleSheet(specBtnStyle); +} + + +static bool getNewColor(atcore_float3& color) +{ + QColor currentColor; + currentColor.setRgbF(color.x, color.y, color.z); + + QColor newColor = QColorDialog::getColor(currentColor, NV_NULL); + if(newColor.isValid()) + { + qreal r,g,b; + newColor.getRgbF(&r, &g, &b); + + color.x = r; + color.y = g; + color.z = b; + return true; + } + + return false; +} + +void DisplayLightPanel::on_btnLightColor_clicked() +{ + Light* pLight = Light::GetFirstSelectedLight(); + + atcore_float3 color = pLight->m_color; + + if (getNewColor(color)) + setButtonColor(ui.btnLightColor, color.x, color.y, color.z); + + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight || !pLight->m_selected) + continue; + + pLight->m_color = color; + } +} + +inline void SetTextureIcon(QPushButton* pButton, bool enabled) +{ + if (enabled) + pButton->setIcon(QIcon(":/AppMainWindow/images/TextureEnabled_icon.png")); + else + pButton->setIcon(QIcon(":/AppMainWindow/images/TextureIsUsed_icon.png")); +} + +void DisplayLightPanel::on_btnLightColorTex_clicked() +{ + QString texName = AppMainWindow::Inst().OpenTextureFile(); + QFileInfo fileInfo(texName); + QByteArray ba = fileInfo.absoluteFilePath().toLocal8Bit(); + + if (Light::SetEnvTextureFromFilePath((const char*)ba)) + SetTextureIcon(ui.btnLightColorTex, Light::GetEnvTextureFilePath().empty()); +} + +void DisplayLightPanel::on_btnLightColorTexReload_clicked() +{ + std::string path = Light::GetEnvTextureFilePath(); + if (Light::SetEnvTextureFromFilePath(path.c_str())) + SetTextureIcon(ui.btnLightColorTex, Light::GetEnvTextureFilePath().empty()); +} + +void DisplayLightPanel::on_btnLightColorTexClear_clicked() +{ + Light::SetEnvTextureFromFilePath(nullptr); + SetTextureIcon(ui.btnLightColorTex, Light::GetEnvTextureFilePath().empty()); +} + +void DisplayLightPanel::updateUI() +{ + Light* pLight = Light::GetFirstSelectedLight(); + if (!pLight) + return; + + atcore_float3& color = pLight->m_color; + setButtonColor(ui.btnLightColor, color.x, color.y, color.z); + + ui.btnVisualizeLight->setChecked(pLight->m_visualize); + + ui.spinLightDistance->setValue(pLight->GetDistance()); + ui.spinLightIntensity->setValue(pLight->m_intensity); + + ui.btnLightUseShadow->setChecked(pLight->m_useShadows); + ui.btnLightEnable->setChecked(pLight->m_enable); + + ui.btnVisualizeShadowMap->setChecked(GlobalSettings::Inst().m_visualizeShadowMap); + + ui.cbShadowMapResolution->setCurrentIndex(pLight->m_shadowMapResolutionIndex); + + ui.btnLinkLightEnable->setChecked(Light::GetLinkLightOption()); + + SetTextureIcon(ui.btnLightColorTex, Light::GetEnvTextureFilePath().empty()); +} + +void DisplayLightPanel::updateValues() +{ + _isUpdatingUI = true; + + ui.listSelectedLight->clear(); + for (int i = 0; i < 4; i++) + { + Light* pLight = Light::GetLight(i); + if (!pLight) + continue; + + const char* lightName = pLight->m_name.c_str(); + bool selected = pLight->m_selected; + + ui.listSelectedLight->addItem(lightName); + ui.listSelectedLight->item(i)->setSelected(selected); + } + ui.listSelectedLight->setSelectionMode(QAbstractItemView::ExtendedSelection); + + updateUI(); + + _isUpdatingUI = false; +} diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayLightPanel.h b/tools/ArtistTools/source/CoreLib/Window/DisplayLightPanel.h new file mode 100644 index 0000000..e22eae4 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayLightPanel.h @@ -0,0 +1,47 @@ +#ifndef DisplayLightPanel_h__ +#define DisplayLightPanel_h__ + +#include <QtWidgets/QWidget> +#include "ui_DisplayLightPanel.h" + +#include "corelib_global.h" + +class DisplayLightPanel : public QWidget +{ + Q_OBJECT + +public: + DisplayLightPanel(QWidget* parent); + + public: + CORELIB_EXPORT void updateValues(); + + public slots: + CORELIB_EXPORT void onListSelectionChanged(); + + CORELIB_EXPORT void on_spinLightDistance_valueChanged(double v); + CORELIB_EXPORT void on_spinLightIntensity_valueChanged(double v); + + CORELIB_EXPORT void on_btnLightUseShadow_stateChanged(int state); + CORELIB_EXPORT void on_btnVisualizeLight_stateChanged(int state); + CORELIB_EXPORT void on_btnLightEnable_stateChanged(int state); + CORELIB_EXPORT void on_btnLinkLightEnable_stateChanged(int state); + + CORELIB_EXPORT void on_btnLightColor_clicked(); + CORELIB_EXPORT void on_btnLightColorTex_clicked(); + CORELIB_EXPORT void on_btnLightColorTexReload_clicked(); + CORELIB_EXPORT void on_btnLightColorTexClear_clicked(); + + CORELIB_EXPORT void on_btnVisualizeShadowMap_stateChanged(int state); + + CORELIB_EXPORT void on_cbShadowMapResolution_currentIndexChanged(int index); + +private: + Ui::DisplayLightPanel ui; + bool _isUpdatingUI; + void setButtonColor(QPushButton *button, float r, float g, float b); + + void updateUI(); +}; + +#endif diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayMeshesPanel.cpp b/tools/ArtistTools/source/CoreLib/Window/DisplayMeshesPanel.cpp new file mode 100644 index 0000000..67ca141 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayMeshesPanel.cpp @@ -0,0 +1,177 @@ +#include "DisplayMeshesPanel.h" + +#include <QtWidgets/QGridLayout> +#include <QtWidgets/QHBoxLayout> +#include <QtWidgets/QPushButton> + +#include "AppMainWindow.h" + +#include "SimpleScene.h" + +#ifndef NV_ARTISTTOOLS +#include "FurCharacter.h" +#else +#endif // NV_ARTISTTOOLS + +////////////////////////////////////////////////////////////////////////// +// DisplayMeshItem + +StateViewItem::StateViewItem( QWidget* parent, unsigned int id, MeshViewState view /*= VS_VISIABLE*/ ) + : _id(id) +{ + static QIcon iconVisible(":/AppMainWindow/images/visibilityToggle_visible.png"); + static QIcon iconNotVisible(":/AppMainWindow/images/visibilityToggle_notVisible.png"); + + _parent = qobject_cast<DisplayMeshesPanel*>(parent); + + _layout = new QHBoxLayout(this); + _layout->setObjectName(QString::fromUtf8("boxLayout")); + _layout->setMargin(0); + + this->setLayout(_layout); + + _btn = new QPushButton(this); + + _btn->setObjectName(QString::fromUtf8("btnToggleView")); + QSizePolicy sizePolicy1(QSizePolicy::Ignored, QSizePolicy::Fixed); + sizePolicy1.setHorizontalStretch(0); + sizePolicy1.setVerticalStretch(0); + sizePolicy1.setHeightForWidth(_btn->sizePolicy().hasHeightForWidth()); + _btn->setSizePolicy(sizePolicy1); + _btn->setMinimumSize(QSize(16, 16)); + _btn->setMaximumSize(QSize(16, 16)); + _btn->setAutoFillBackground(false); + _btn->setCheckable(true); + _btn->setChecked(view == VS_VISIABLE); + _btn->setIcon( (view == VS_VISIABLE) ? iconVisible : iconNotVisible); + + _layout->addWidget(_btn); + + _spacer = new QSpacerItem(20, 40, QSizePolicy::Expanding, QSizePolicy::Ignored); + _layout->addItem(_spacer); + + QMetaObject::connectSlotsByName(this); +} + +void StateViewItem::on_btnToggleView_clicked() +{ + static QIcon iconVisible(":/AppMainWindow/images/visibilityToggle_visible.png"); + static QIcon iconNotVisible(":/AppMainWindow/images/visibilityToggle_notVisible.png"); + + bool bVis = _btn->isChecked(); + _btn->setIcon(bVis ? iconVisible : iconNotVisible); + + _parent->EmitToggleSignal(_id, bVis); + + qDebug("%s", __FUNCTION__); +} + + +////////////////////////////////////////////////////////////////////////// +DisplayMeshesPanel::DisplayMeshesPanel( QWidget* parent ) + :QFrame(parent) +{ + _layout = new QGridLayout(this); + _layout->setObjectName(QString::fromUtf8("gridLayout")); + + this->setLayout(_layout); + + //QString styleSheet = + // "QPushButton#btnToggleView:checked {border:2px solid gray; background:rgb(118,180,0);} \n" \ + // "QPushButton#btnToggleView:pressed {border:2px solid gray; background:rgb(118,180,0);}"; + //setStyleSheet(styleSheet); +} + +///////////////////////////////////////////////////////////////////////////////////////// +void DisplayMeshesPanel::updateValues() +{ + ClearItems(); + +#ifndef NV_ARTISTTOOLS + FurCharacter& character = SimpleScene::Inst()->GetFurCharacter(); + int nMesh = character.GetMeshCount(); + for (int i = 0; i < nMesh; ++i) + { + bool used = character.GetMeshUsed(i); + if (!used) + continue; + + const char* name = character.GetMeshName(i); + bool visible = character.GetMeshVisible(i); + + StateViewItem::MeshViewState visState = visible ? StateViewItem::VS_VISIABLE : StateViewItem::VS_INVISIBLE; + + AddMeshItem(QString(name), i, visState); + } +#else + CoreLib::Inst()->DisplayMeshesPanel_updateValues(); +#endif // NV_ARTISTTOOLS +} + +///////////////////////////////////////////////////////////////////////////////////////// +void DisplayMeshesPanel::AddMeshItem( QString name, unsigned int id, StateViewItem::MeshViewState view ) +{ + StateViewItem* item; + item = new StateViewItem(this, id, view); + + QSizePolicy sizePolicy1(QSizePolicy::Expanding, QSizePolicy::Fixed); + sizePolicy1.setHorizontalStretch(0); + sizePolicy1.setVerticalStretch(0); + + QLabel* label = new QLabel(name, this); + label->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label->setSizePolicy(sizePolicy1); + + int row = _items.size(); + _layout->addWidget(label, row, 0, 1, 1); + + _layout->addWidget(item, row, 1, 1, 1); + + Q_ASSERT(_items.find(id) == _items.end()); + + ItemUI ui; + ui.label = label; + ui.viewItem = item; + _items[id] = ui; +} + +///////////////////////////////////////////////////////////////////////////////////////// +void DisplayMeshesPanel::EmitToggleSignal( unsigned int id, bool visible ) +{ + emit MeshViewSignal(id, visible); + +#ifndef NV_ARTISTTOOLS + FurCharacter& character = SimpleScene::Inst()->GetFurCharacter(); + character.SetMeshVisible(id, visible); +#else + CoreLib::Inst()->DisplayMeshesPanel_EmitToggleSignal(id, visible); +#endif // NV_ARTISTTOOLS +} + +///////////////////////////////////////////////////////////////////////////////////////// +void DisplayMeshesPanel::RemoveMeshItem( unsigned int id ) +{ + if(_items.find(id) != _items.end()) + { + ItemUI ui = _items[id]; + delete ui.label; + delete ui.viewItem; + _items.remove(id); + } + else + { + Q_ASSERT("Mesh item doesn't exist!!"); + } +} + +///////////////////////////////////////////////////////////////////////////////////////// +void DisplayMeshesPanel::ClearItems() +{ + Q_FOREACH(ItemUI ui, _items) + { + delete ui.label; + delete ui.viewItem; + } + + _items.clear(); +} diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayMeshesPanel.h b/tools/ArtistTools/source/CoreLib/Window/DisplayMeshesPanel.h new file mode 100644 index 0000000..ecc5b49 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayMeshesPanel.h @@ -0,0 +1,80 @@ +#ifndef DisplayMeshesPanel_h__ +#define DisplayMeshesPanel_h__ + +#include <QtWidgets/QFrame> +#include <QtCore/QMap> +#ifndef NV_ARTISTTOOLS +#include "ui_LodPanel.h" +#else +#include <QtWidgets/QLabel> +#endif // NV_ARTISTTOOLS + +#include "corelib_global.h" + +class QPushButton; +class QGridLayout; +class QHBoxLayout; +class QSpacerItem; + +class DisplayMeshesPanel; +class StateViewItem : public QWidget +{ + Q_OBJECT + +public: + enum MeshViewState + { + VS_INVISIBLE = 0, + VS_VISIABLE = 1, + }; + + StateViewItem(QWidget* parent, unsigned int id, MeshViewState view = VS_VISIABLE); + + public slots: + CORELIB_EXPORT void on_btnToggleView_clicked(); + +private: + unsigned int _id; + + QHBoxLayout* _layout; + QPushButton* _btn; + QSpacerItem* _spacer; + + DisplayMeshesPanel* _parent; +}; + +class DisplayMeshesPanel : public QFrame +{ + Q_OBJECT + +public: + DisplayMeshesPanel(QWidget* parent); + + void updateValues(); + + // client code should make sure the 'id' is unique! + CORELIB_EXPORT void AddMeshItem(QString name, unsigned int id, StateViewItem::MeshViewState view = StateViewItem::VS_VISIABLE); + CORELIB_EXPORT void RemoveMeshItem(unsigned int id); + CORELIB_EXPORT void ClearItems(); + +signals: + void MeshViewSignal(unsigned int id, bool visible); + +protected: + virtual void EmitToggleSignal(unsigned int id, bool visible); + +private: + QGridLayout* _layout; + + struct ItemUI + { + StateViewItem* viewItem; + QLabel* label; + }; + + QMap<unsigned int, ItemUI> _items; + + friend class StateViewItem; +}; + +#endif // GraphicalMaterialPanel_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayPreferencesPanel.cpp b/tools/ArtistTools/source/CoreLib/Window/DisplayPreferencesPanel.cpp new file mode 100644 index 0000000..fe4b808 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayPreferencesPanel.cpp @@ -0,0 +1,906 @@ +#include "DisplayPreferencesPanel.h" + +#include "AppMainWindow.h" + +#include "SimpleScene.h" +#include "GlobalSettings.h" +#include <QtWidgets/QInputDialog> +#include <QtWidgets/QMessageBox> +#include <QtWidgets/QFileDialog> + +#include "PlaylistParams.h" +//#include <Nv/Blast/NvHairCommon.h> +#include "NvParameterized.h" +#include "XmlSerializer.h" +#include "NsFileBuffer.h" +#include "NvTraits.h" +#include "NsMemoryBuffer.h" +#include "ViewerOutput.h" +#include "Settings.h" + +#include "Gamepad.h" + +const QString sPlaylistExt = "plist"; +bool bRefreshingComboBox = false; + +DisplayPreferencesPanel::DisplayPreferencesPanel(QWidget* parent) + : + QWidget(parent) + , idxCurrentPlaylist(-1) + , idxCurrentProj(-1) + , playlistProjectsDirty(false) +{ + ui.setupUi(this); + + ui.btnBackgroundTex->setIcon(QIcon(":/AppMainWindow/images/TextureEnabled_icon.png")); + ui.btnBackgroundTex->setIconSize(QSize(12,12)); + ui.btnBackgroundTexClear->setIcon(QIcon(":/AppMainWindow/images/Remove_icon.png")); + + ui.btnPlaylistsRename->setIcon(QIcon(":/AppMainWindow/images/EditWrench.png")); + ui.btnPlaylistsAdd->setIcon(QIcon(":/AppMainWindow/images/Add.png")); + ui.btnPlaylistsReload->setIcon(QIcon(":/AppMainWindow/images/refreshReload.png")); + ui.btnPlaylistsRemove->setIcon(QIcon(":/AppMainWindow/images/Remove_icon.png")); + + ui.btnPlaylistAddProj->setIcon(QIcon(":/AppMainWindow/images/Add.png")); + ui.btnPlaylistRemoveProj->setIcon(QIcon(":/AppMainWindow/images/Remove_icon.png")); + ui.btnPlaylistProjGoUp->setIcon(QIcon(":/AppMainWindow/images/Up.png")); + ui.btnPlaylistProjGoDown->setIcon(QIcon(":/AppMainWindow/images/Down.png")); + + ui.btnPlaylistsPlay->setIcon(QIcon(":/AppMainWindow/images/playlist.png")); + + //QObject::connect(ui.listWidgetPlaylist, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(playlistDoubleClicked(QListWidgetItem*))); + + ConfigSpinBox<SlideSpinBoxF>(ui.spinCameraFOV, 5.0, 180.0, 1.0); +} + +DisplayPreferencesPanel::~DisplayPreferencesPanel() +{ +} + +void DisplayPreferencesPanel::on_spinRenderPlayRateFPS_valueChanged(double v) +{ + GlobalSettings::Inst().setRenderFps((float)v); +} + +void DisplayPreferencesPanel::on_spinSimulationRateFPS_valueChanged(double v) +{ + GlobalSettings::Inst().setSimulationFps((float)v); +} + +void DisplayPreferencesPanel::on_spinCameraFOV_valueChanged(double v) +{ + GlobalSettings::Inst().m_fovAngle = v; +} + +void DisplayPreferencesPanel::on_cbAntialiasing_currentIndexChanged( int index ) +{ + GlobalSettings::Inst().m_msaaOption = index; +} + +void DisplayPreferencesPanel::on_cbUpAxis_currentIndexChanged( int index ) +{ + switch (index) + { + case 0: // y up + SimpleScene::Inst()->ResetUpDir(false); + break; + case 1: // z up + SimpleScene::Inst()->ResetUpDir(true); + break; + } + SimpleScene::Inst()->SetProjectModified(true); +} + +void DisplayPreferencesPanel::on_cbHandedness_currentIndexChanged( int index ) +{ + switch (index) + { + case 0: // rhs + SimpleScene::Inst()->ResetLhs(false); + break; + case 1: // lhs + SimpleScene::Inst()->ResetLhs(true); + break; + } + SimpleScene::Inst()->SetProjectModified(true); +} + +void DisplayPreferencesPanel::on_cbSceneUnit_currentIndexChanged( int index ) +{ + GlobalSettings::Inst().m_sceneUnitIndex = index; +} + +void DisplayPreferencesPanel::on_cbNavigationStyle_currentIndexChanged( int index ) +{ + AppMainWindow::Inst().setNavigationStyle(index); +} + +void DisplayPreferencesPanel::on_btnBackgroundTex_clicked() +{ + if (SimpleScene::Inst()->LoadBackgroundTextureFile()) + ui.btnBackgroundTex->setIcon(QIcon(":/AppMainWindow/images/TextureIsUsed_icon.png")); + else + ui.btnBackgroundTex->setIcon(QIcon(":/AppMainWindow/images/TextureEnabled_icon.png")); + + updateValues(); + SimpleScene::Inst()->SetProjectModified(true); +} + +void DisplayPreferencesPanel::on_btnBackgroundTexClear_clicked() +{ + SimpleScene::Inst()->ClearBackgroundTexture(); + ui.btnBackgroundTex->setIcon(QIcon(":/AppMainWindow/images/TextureEnabled_icon.png")); + updateValues(); +} + +void DisplayPreferencesPanel::updateValues() +{ + GlobalSettings& globalSettings = GlobalSettings::Inst(); + + ui.spinRenderPlayRateFPS->setValue(globalSettings.m_renderFps); + ui.spinSimulationRateFPS->setValue(globalSettings.m_simulationFps); + ui.cbUpAxis->setCurrentIndex(globalSettings.m_zup); + ui.cbHandedness->setCurrentIndex(globalSettings.m_lhs); + ui.spinCameraFOV->setValue(globalSettings.m_fovAngle); + ui.cbSceneUnit->setCurrentIndex(globalSettings.m_sceneUnitIndex); + ui.cbNavigationStyle->setCurrentIndex(AppMainWindow::Inst().getNavigationStyle()); + ui.cbAntialiasing->setCurrentIndex(globalSettings.m_msaaOption); + + savePlaylistProjects(); + reloadComboxBoxPlaylists(); + + //// sync playlist to gamepad + //static bool bOnce = true; + //if (bOnce) + //{ + // bOnce = false; + // assignPlayPlaylistToGamepad(0); + //} +} + +void DisplayPreferencesPanel::reloadComboxBoxPlaylists() +{ + playlistsLoader.loadPlaylistsFromMediaPath(); + // set playlist combo box + //idxCurrentPlaylist = ui.cbPlaylists->currentIndex(); + bRefreshingComboBox = true; + ui.cbPlaylists->clear(); + int count = playlistsLoader.playlists.size(); + for (int i = 0; i < count; ++i) + { + QFileInfo& fi = playlistsLoader.playlists[i]; + std::string fn = fi.fileName().toUtf8().data(); + ui.cbPlaylists->addItem(fi.fileName()); + } + bRefreshingComboBox = false; + if (idxCurrentPlaylist > count || idxCurrentPlaylist < 0) + idxCurrentPlaylist = 0; + + ui.cbPlaylists->setCurrentIndex(idxCurrentPlaylist); + + // refresh project list + reloadListboxPorjectsFromPlayist(); +} + +void DisplayPreferencesPanel::runDemoCommandline() +{ + // run demos if command line asks + static bool once = true; + if (once) + { + once = false; + std::string demoPlaylist = AppSettings::Inst().GetOptionValue("User/FurDemoPlaylist")->Value.String; + if (demoPlaylist.size() > 1) + { + QString demoList = QString(demoPlaylist.c_str()).toUpper(); + int count = playlistsLoader.playlists.size(); + for (int i = 0; i < count; ++i) + { + QFileInfo& fi = playlistsLoader.playlists[i]; + QString fname = fi.fileName().toUpper(); + if (fname == demoList) + { + idxCurrentPlaylist = i; + ui.cbPlaylists->setCurrentIndex(idxCurrentPlaylist); + playPlaylist(idxCurrentPlaylist); + return; + } + } + viewer_msg(QString("Cannot find playlist, " + demoList).toUtf8().data()); + } + } +} + +void DisplayPreferencesPanel::reloadListboxPorjectsFromPlayist() +{ + int count = playlistsLoader.getProjectsInPlaylist(idxCurrentPlaylist, playlistProjects); + refreshListboxPorjects(); +} + +void DisplayPreferencesPanel::savePlaylistProjects() +{ + if (playlistProjectsDirty) + { + playlistsLoader.saveProjectsInPlaylist(idxCurrentPlaylist, playlistProjects); + playlistProjectsDirty = false; + } +} + +void DisplayPreferencesPanel::refreshListboxPorjects() +{ + int count = playlistProjects.size(); + ui.listWidgetPlaylist->clear(); + ui.listWidgetPlaylist->setSortingEnabled(false); + ui.listWidgetPlaylist->setSelectionMode(QAbstractItemView::SingleSelection); + QStringList tips; + for (int i = 0; i < count; ++i) + { + QString fullName = playlistsLoader.convertToAbsoluteFilePath(playlistProjects[i]); + QFileInfo fi(fullName); + tips.append(fi.absoluteFilePath()); + std::string tmp = fi.absoluteFilePath().toUtf8().data(); + ui.listWidgetPlaylist->addItem(fi.fileName()); + } + ui.listWidgetPlaylist->setTips(tips); + if (idxCurrentProj > count || idxCurrentProj < 0) + { + idxCurrentProj = 0; + } + ui.listWidgetPlaylist->setCurrentRow(idxCurrentProj); +} + +void DisplayPreferencesPanel::SelectPlayList(QString& name) +{ + QString newName = name.toUpper(); + int count = playlistsLoader.playlists.size(); + for (int i = 0; i < count; ++i) + { + QFileInfo& fi = playlistsLoader.playlists[i]; + if (fi.baseName().toUpper() == newName) + { + ui.cbPlaylists->setCurrentIndex(i); + break; + } + } +} + +void DisplayPreferencesPanel::on_cbPlaylists_currentIndexChanged(int index) +{ + savePlaylistProjects(); + if (!bRefreshingComboBox) + { + idxCurrentPlaylist = ui.cbPlaylists->currentIndex(); + reloadListboxPorjectsFromPlayist(); + } +} + +void DisplayPreferencesPanel::SelectProject(QString& name) +{ + QString newName = name.toUpper(); + std::string strNew = newName.toUtf8().data(); + int count = playlistProjects.size(); + for (int i = 0; i < count; ++i) + { + QString& str = playlistProjects[i]; + //QFileInfo fi(str); + //std::string stmp = fi.absoluteFilePath().toUtf8().data(); + //if (fi.absoluteFilePath().toUpper() == newName) + if (str.toUpper() == newName) + { + ui.listWidgetPlaylist->setCurrentRow(i); + break; + } + } +} + +void DisplayPreferencesPanel::on_listWidgetPlaylist_itemSelectionChanged() +{ + idxCurrentProj = ui.listWidgetPlaylist->currentRow(); +} + +void DisplayPreferencesPanel::on_listWidgetPlaylist_itemDoubleClicked(QListWidgetItem* pItem) +{ + idxCurrentProj = ui.listWidgetPlaylist->currentRow(); + if (idxCurrentProj < 0) + return; + QString fn = playlistProjects[idxCurrentProj]; + QString fullname = PlaylistsLoader::convertToAbsoluteFilePath(fn); + AppMainWindow::Inst().openProject(fullname); + char msg[1024]; + sprintf(msg, "Blast Viewer - %s", fullname.toUtf8().data()); + AppMainWindow::Inst().setWindowTitle(msg); +} + +void DisplayPreferencesPanel::on_btnPlaylistsRename_clicked() +{ + idxCurrentPlaylist = ui.cbPlaylists->currentIndex(); + if (idxCurrentPlaylist < 0) + return; + + QFileInfo& fi = playlistsLoader.playlists[idxCurrentPlaylist]; + bool isOK = false; + QString newBaseName = QInputDialog::getText(NULL, "Rename Playlist - " + fi.fileName(), + "Input a new name for the playlist, " + fi.fileName(), QLineEdit::Normal, + fi.baseName(), &isOK); + if (isOK) + { + bool ok = playlistsLoader.rename(idxCurrentPlaylist, newBaseName); + if (ok) + { + reloadComboxBoxPlaylists(); + SelectPlayList(newBaseName); + } + else + { + QMessageBox::warning(this, "Fail to rename a playlist", + "Fail to rename a playlist. The failure could relate to name duplication or hardware failure.", + QMessageBox::Close); + } + } +} + +void DisplayPreferencesPanel::on_btnPlaylistsAdd_clicked() +{ + savePlaylistProjects(); + + bool isOK = false; + QString sInput = QInputDialog::getText(NULL, "Create New Playlist", "Input a name for the new playlist.", QLineEdit::Normal, "", &isOK); + if (isOK) + { + QString newName = sInput.trimmed(); + bool ok = playlistsLoader.add(newName); + if (ok) + { + reloadComboxBoxPlaylists(); + // select the new one + SelectPlayList(newName); + } + else + { + QMessageBox::warning(this, "Fail to add new playlist", + "Fail to add new playlist. The failure could relate to name duplication or hardware failure.", + QMessageBox::Close); + } + } +} + +void DisplayPreferencesPanel::on_btnPlaylistsReload_clicked() +{ + savePlaylistProjects(); + reloadComboxBoxPlaylists(); +} + +void DisplayPreferencesPanel::on_btnPlaylistsRemove_clicked() +{ + savePlaylistProjects(); + idxCurrentPlaylist = ui.cbPlaylists->currentIndex(); + if (idxCurrentPlaylist < 0) + return; + + bool ok = playlistsLoader.remove(idxCurrentPlaylist); + if (ok) + { + reloadComboxBoxPlaylists(); + } + else + { + QMessageBox::warning(this, "Fail to remove a playlist", + "Fail to remove a playlist. The failure could relate to hardware.", + QMessageBox::Close); + } +} + +void DisplayPreferencesPanel::on_btnPlaylistAddProj_clicked() +{ + static QString lastPath; + if (lastPath.size() < 1) + { + lastPath = PlaylistsLoader::mediaPath; + } + QString fileNameInput = QFileDialog::getOpenFileName(this, "Open Hair Project File", lastPath, "Hair Project File (*.furproj)"); + if (!QFile::exists(fileNameInput)) + return; + std::string tmp = fileNameInput.toUtf8().data(); + QString fileName = PlaylistsLoader::convertToSaveingFilePath(fileNameInput); + if (fileName.size() < 1) + { + return; + } + lastPath = QFileInfo(fileNameInput).absolutePath(); + std::string tmp2 = fileName.toUtf8().data(); + playlistProjects.append(fileName); + refreshListboxPorjects(); + //QFileInfo fi(fileName); + SelectProject(fileName);// fi.absoluteFilePath()); + playlistProjectsDirty = true; +} + +void DisplayPreferencesPanel::on_btnPlaylistProjGoUp_clicked() +{ + idxCurrentProj = ui.listWidgetPlaylist->currentRow(); + if (idxCurrentProj <= 0) + return; + + QString tmp = playlistProjects[idxCurrentProj]; + playlistProjects[idxCurrentProj] = playlistProjects[idxCurrentProj - 1]; + playlistProjects[idxCurrentProj - 1] = tmp; + + refreshListboxPorjects(); + SelectProject(tmp); + + playlistProjectsDirty = true; +} + +void DisplayPreferencesPanel::on_btnPlaylistProjGoDown_clicked() +{ + int count = playlistProjects.size(); + idxCurrentProj = ui.listWidgetPlaylist->currentRow(); + if (idxCurrentProj < 0 || idxCurrentProj>= count -1) + return; + + QString tmp = playlistProjects[idxCurrentProj]; + playlistProjects[idxCurrentProj] = playlistProjects[idxCurrentProj + 1]; + playlistProjects[idxCurrentProj + 1] = tmp; + + refreshListboxPorjects(); + SelectProject(tmp); + + playlistProjectsDirty = true; +} + +void DisplayPreferencesPanel::on_btnPlaylistRemoveProj_clicked() +{ + int count = playlistProjects.size(); + idxCurrentProj = ui.listWidgetPlaylist->currentRow(); + if (idxCurrentProj < 0 || idxCurrentProj >= count) + { + return; + } + + playlistProjects.removeAt(idxCurrentProj); + + refreshListboxPorjects(); + playlistProjectsDirty = true; +} + +void DisplayPreferencesPanel::assignPlayPlaylistToGamepad(int idx) +{ + if (idx == -1) + idx = idxCurrentPlaylist; + int count = playlistsLoader.getProjectsInPlaylist(idx, playlistProjects); + if (count < 1) + { + viewer_msg("Playlist is empty."); + return; + } + QList<QString> files; + for (int i = 0; i < count; ++i) + { + QString fname = PlaylistsLoader::convertToAbsoluteFilePath(playlistProjects[i]); + if (fname.size() > 0) + { + files.append(fname); + } + } + + Gamepad& theGamepad = Gamepad::Instance(); + theGamepad.SetDemoProjects(files); +} + +void DisplayPreferencesPanel::playPlaylist(int idx) +{ + assignPlayPlaylistToGamepad(idx); + Gamepad& theGamepad = Gamepad::Instance(); + theGamepad.SetDemoMode(true); +} + +void DisplayPreferencesPanel::on_btnPlaylistsPlay_clicked() +{ + savePlaylistProjects(); + + idxCurrentPlaylist = ui.cbPlaylists->currentIndex(); + if (idxCurrentPlaylist < 0) + { + viewer_msg("No available playlists."); + return; + } + playPlaylist(idxCurrentPlaylist); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +using namespace nvidia; +using namespace nvidia::parameterized; + +QString PlaylistsLoader::projectPath; +QString PlaylistsLoader::mediaPath; + +#include "FoundationHolder.h" + +struct PlaylistParamsContext +{ + //nvidia::NvFoundation* mFoundation; + NvParameterized::Traits* mTraits; + PlaylistParamsFactory* mPlaylistParamsFactory; +}; + +PlaylistsLoader::PlaylistsLoader() + :pContext(nullptr) +{ +} + +PlaylistsLoader::~PlaylistsLoader() +{ +} + +void PlaylistsLoader::CreatePlaylistParamsContext() +{ + if (pContext) + return; + + PlaylistParamsContext* context = new PlaylistParamsContext; + //context->mFoundation = FoundationHolder::GetFoundation(); + FoundationHolder::GetFoundation(); + //assert(context->mFoundation != NV_NULL); + + context->mTraits = NvParameterized::createTraits(); + context->mPlaylistParamsFactory = new PlaylistParamsFactory; + context->mTraits->registerFactory(*context->mPlaylistParamsFactory); + pContext = context; +} + +void PlaylistsLoader::ReleasePlaylistParamsContext() +{ + if (pContext) + { + pContext->mTraits->release(); + delete pContext->mPlaylistParamsFactory; + delete pContext; + pContext = nullptr; + } +} + +void PlaylistsLoader::loadPlaylistsFromMediaPath() +{ + if (projectPath.isEmpty()) + { + QString appDir = qApp->applicationDirPath(); + QDir dirTmp(appDir); + if (dirTmp.cd("./media/playlists")) + projectPath = dirTmp.absolutePath(); + else if (dirTmp.cd("../media/playlists")) + projectPath = dirTmp.absolutePath(); + else if (dirTmp.cd("../../media/playlists")) + projectPath = dirTmp.absolutePath(); + else if (dirTmp.cd("../../media")) + { + bool ok = dirTmp.mkdir("playlists"); + if (dirTmp.cd("playlists")) + { + projectPath = dirTmp.absolutePath(); + } + } + if (!projectPath.isEmpty()) + { + if (dirTmp.cd("..")) + { + mediaPath = dirTmp.absolutePath(); + } + else + { + mediaPath = projectPath + "/.."; + } + } + } + if (!projectPath.isEmpty()) + { + playlists.clear(); + + QStringList filters; + filters << (QString("*.") + sPlaylistExt); + QDirIterator dir_iterator(projectPath, filters, QDir::Files | QDir::NoSymLinks, QDirIterator::NoIteratorFlags); //QDirIterator::Subdirectories + while (dir_iterator.hasNext()) + { + dir_iterator.next(); + QFileInfo file_info = dir_iterator.fileInfo(); + std::string absolute_file_path = file_info.absoluteFilePath().toUtf8().data(); + playlists.append(file_info); + } + } +} + +bool PlaylistsLoader::rename(int idx, QString& newBaseName) +{ + int count = playlists.size(); + if (idx >= 0 && idx < count) + { + QFileInfo& finfo = playlists[idx]; + QString fn = finfo.baseName().toUpper(); + QString fnNew = newBaseName.toUpper(); + if (fn != fnNew) + { + QFileInfo nfi(projectPath, newBaseName + "." + sPlaylistExt); + QString fullNewName = nfi.absoluteFilePath(); + std::string fntmp = fullNewName.toUtf8().data(); + bool exist = QFile::exists(fullNewName); + if (exist) + { + return false; + } + bool ok = QFile::rename(finfo.absoluteFilePath(), fullNewName); + if (ok) + { + finfo.setFile(fullNewName); + exist = QFile::exists(fullNewName); + if (!exist) + { + return false; + } + } + return ok; + } + return true; + } + return false; +} + +bool PlaylistsLoader::remove(int idx) +{ + int count = playlists.size(); + if (idx >= 0 && idx < count) + { + QFileInfo& finfo = playlists[idx]; + std::string fn = finfo.fileName().toUtf8().data(); + bool ok = QFile::remove(finfo.absoluteFilePath()); + if (ok) + { + playlists.removeAt(idx); + } + return ok; + } + return false; +} + +bool PlaylistsLoader::saveProjectsInPlaylist(int idx, QList<QString>& projects) +{ + int count = playlists.size(); + if (idx < 0 || idx >= count) + return false; + + CreatePlaylistParamsContext(); + if (!pContext) + return false; + + std::string tempFilePath = playlists[idx].absoluteFilePath().toUtf8().data(); + NvParameterized::XmlSerializer serializer(pContext->mTraits); + NvFileBuf* stream = new NvFileBufferBase(tempFilePath.c_str(), NvFileBuf::OPEN_WRITE_ONLY); + if (!stream || !stream->isOpen()) + { + // file open error + if (stream) stream->release(); + return false; + } + NvParameterized::Traits* traits = pContext->mTraits; + int numObjects = 0; + const int kMaxObjects = 1; + NvParameterized::Interface* objects[kMaxObjects]; + + PlaylistParams* params = new PlaylistParams(traits); + objects[numObjects++] = params; + NvParameterized::Interface* iface = static_cast<NvParameterized::Interface*>(params); + + if (1) + { + nvidia::parameterized::PlaylistParams* params = static_cast<nvidia::parameterized::PlaylistParams*>(iface); + nvidia::parameterized::PlaylistParamsNS::ParametersStruct& targetDesc = params->parameters(); + + NvParameterized::Handle handle(iface); + if (iface->getParameterHandle("furprojFilePaths", handle) == NvParameterized::ERROR_NONE) + { + int num = projects.size(); + + std::vector<std::string> strArray; + const char** strOutput = new const char*[num]; + + for (int i = 0; i < num; i++) + { + std::string proj = projects[i].toUtf8().data(); + strArray.push_back(proj); + strOutput[i] = strArray[i].c_str(); + } + + handle.resizeArray(num); + handle.setParamStringArray(strOutput, num); + + delete[] strOutput; + } + } + + NV_ASSERT(numObjects <= kMaxObjects); + NvParameterized::Serializer::ErrorType serError = NvParameterized::Serializer::ERROR_NONE; + bool isUpdate = false; + serError = serializer.serialize(*stream, (const NvParameterized::Interface**)&objects[0], numObjects, isUpdate); + for (int idx = 0; idx < numObjects; ++idx) + { + delete objects[idx]; + } + stream->release(); + ReleasePlaylistParamsContext(); + return true; +} + +QString PlaylistsLoader::convertToAbsoluteFilePath(QString& filePath) +{ + QString fname; + bool bCanBeRelativePath = false; + bool bAbsPath = (filePath.indexOf(':') >= 0); + if (bAbsPath) + { + if (QFile::exists(filePath)) + { + fname = filePath; + } + else + { + viewer_msg(QString(filePath + " does not exist.").toUtf8().data()); + } + std::string tmp2 = fname.toUtf8().data(); + return fname; + } + else + { + QFileInfo fi(mediaPath + "/" + filePath); + fname = fi.absoluteFilePath(); + if (!QFile::exists(fname)) + { + viewer_msg(QString(filePath + " does not exist.").toUtf8().data()); + fname = ""; + } + std::string tmp2 = fname.toUtf8().data(); + return fname; + } +} + +QString PlaylistsLoader::convertToSaveingFilePath(QString& filePath) +{ + QString fname; + bool bCanBeRelativePath = false; + bool bAbsPath = (filePath.indexOf(':') >= 0); + if (bAbsPath) + { + if (QFile::exists(filePath)) + { + QFileInfo fi(filePath); + int pos = fi.absoluteFilePath().indexOf(mediaPath, Qt::CaseInsensitive); + if (pos >= 0) + { + // convert to relative path + fname = filePath.right(filePath.size() - (pos + mediaPath.size() + 1)); + } + else + { + fname = fi.absoluteFilePath(); + } + } + else + { + fname = ""; + viewer_msg(QString(filePath + " does not exist.").toUtf8().data()); + } + std::string tmp = fname.toUtf8().data(); + return fname; + } + // do more try + QString tag = "media"; + int pos = filePath.indexOf(tag, Qt::CaseInsensitive); + if (pos >= 0) + { + fname = filePath.right(filePath.size() - (pos + tag.size() + 1)); + } + else + { + fname = filePath; + } + QFileInfo fi(mediaPath + "/" + fname); + std::string tmp = fi.absoluteFilePath().toUtf8().data(); + if (!QFile::exists(fi.absoluteFilePath())) + { + viewer_msg(QString(filePath + " does not exist.").toUtf8().data()); + fname = ""; + } + std::string tmp2 = fname.toUtf8().data(); + return fname; +} + +int PlaylistsLoader::getProjectsInPlaylist(int idx, QList<QString>& projects) +{ + projects.clear(); + + int count = playlists.size(); + if (idx < 0 || idx >= count) + return 0; + + CreatePlaylistParamsContext(); + if (!pContext) + return 0; + + std::string tempFilePath = playlists[idx].absoluteFilePath().toUtf8().data(); + NvFileBuf* stream = new NvFileBufferBase(tempFilePath.c_str(), NvFileBuf::OPEN_READ_ONLY); + if (!stream || !stream->isOpen()) + { + // file open error + if (stream) + stream->release(); + return 0; + } + + NvParameterized::Serializer::DeserializedData data; + NvParameterized::Serializer::ErrorType serError = NvParameterized::Serializer::ERROR_NONE; + NvParameterized::XmlSerializer serializer(pContext->mTraits); + bool isUpdated = false; + serError = serializer.deserialize(*stream, data, isUpdated); + if (data.size() < 1) + { + if (stream) + stream->release(); + return 0; + } + + for (int idx = 0; idx < (int)data.size(); ++idx) + { + NvParameterized::Interface* iface = data[idx]; + if (::strcmp(iface->className(), PlaylistParams::staticClassName()) == 0) + { + nvidia::parameterized::PlaylistParams* params = static_cast<nvidia::parameterized::PlaylistParams*>(iface); + nvidia::parameterized::PlaylistParamsNS::ParametersStruct& srcDesc = params->parameters(); + NvParameterized::Handle handle(iface); + if (iface->getParameterHandle("furprojFilePaths", handle) == NvParameterized::ERROR_NONE) + { + int arraySize; + handle.getArraySize(arraySize); + char** strArray = new char*[arraySize]; + handle.getParamStringArray(strArray, arraySize); + for (int idx = 0; idx < arraySize; ++idx) + { + QString fileName = PlaylistsLoader::convertToSaveingFilePath(QString(strArray[idx])); + if (fileName.size() > 0) + { + std::string tmp = fileName.toUtf8().data(); + projects.append(fileName); + } + } + delete[] strArray; + } + } + } + stream->release(); + ReleasePlaylistParamsContext(); + return projects.size(); +} + +bool PlaylistsLoader::add(QString& name) +{ + int count = playlists.size(); + for (int i = 0; i < count; ++i) + { + QFileInfo& fi = playlists[i]; + if (fi.baseName().toUpper() == name.toUpper()) + { + return false; + } + } + QFileInfo nfi(projectPath, name + "." + sPlaylistExt); + QFile newFile(nfi.absoluteFilePath()); + if (newFile.exists()) + { + return false; + } + newFile.open(QIODevice::WriteOnly); + newFile.close(); + bool exist = QFile::exists(nfi.absoluteFilePath()); + if (!exist) + { + return false; + } + playlists.append(nfi); + return true; +}
\ No newline at end of file diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayPreferencesPanel.h b/tools/ArtistTools/source/CoreLib/Window/DisplayPreferencesPanel.h new file mode 100644 index 0000000..eb57b12 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayPreferencesPanel.h @@ -0,0 +1,100 @@ +#ifndef DisplayPreferencesPanel_h__ +#define DisplayPreferencesPanel_h__ + +#include <QtWidgets/QWidget> +#include <QtCore/QDir> +#include <QtCore/QDirIterator> +#include "TipListView.h" +#include "ui_DisplayPreferencesPanel.h" + +#include "corelib_global.h" + +struct PlaylistParamsContext; + +class PlaylistsLoader +{ +public: + PlaylistsLoader(); + ~PlaylistsLoader(); + + void loadPlaylistsFromMediaPath(); + bool rename(int idx, QString& newName); + bool remove(int idx); + bool add(QString& name); + bool saveProjectsInPlaylist(int idx, QList<QString>& projects); + int getProjectsInPlaylist(int idx, QList<QString>& projects); + + static QString convertToSaveingFilePath(QString& filePath); + static QString convertToAbsoluteFilePath(QString& filePath); + + QList<QFileInfo> playlists; + static QString projectPath; + static QString mediaPath; + +private: + void CreatePlaylistParamsContext(); + void ReleasePlaylistParamsContext(); + PlaylistParamsContext* pContext; +}; + +class DisplayPreferencesPanel : public QWidget +{ + Q_OBJECT + +public: + DisplayPreferencesPanel(QWidget* parent); + ~DisplayPreferencesPanel(); + + public: + void updateValues(); + + public slots: + CORELIB_EXPORT void on_spinRenderPlayRateFPS_valueChanged(double v); + CORELIB_EXPORT void on_spinSimulationRateFPS_valueChanged(double v); + CORELIB_EXPORT void on_spinCameraFOV_valueChanged(double v); + + CORELIB_EXPORT void on_cbSceneUnit_currentIndexChanged(int index); + CORELIB_EXPORT void on_cbAntialiasing_currentIndexChanged(int index); + CORELIB_EXPORT void on_cbUpAxis_currentIndexChanged(int index); + CORELIB_EXPORT void on_cbHandedness_currentIndexChanged(int index); + CORELIB_EXPORT void on_cbNavigationStyle_currentIndexChanged(int index); + CORELIB_EXPORT void on_btnBackgroundTex_clicked(); + CORELIB_EXPORT void on_btnBackgroundTexClear_clicked(); + + CORELIB_EXPORT void on_cbPlaylists_currentIndexChanged(int index); + CORELIB_EXPORT void SelectPlayList(QString& name); + CORELIB_EXPORT void on_listWidgetPlaylist_itemSelectionChanged(); + CORELIB_EXPORT void on_listWidgetPlaylist_itemDoubleClicked(QListWidgetItem* pItem); + CORELIB_EXPORT void SelectProject(QString& name); + + CORELIB_EXPORT void on_btnPlaylistsRename_clicked(); + CORELIB_EXPORT void on_btnPlaylistsAdd_clicked(); + CORELIB_EXPORT void on_btnPlaylistsReload_clicked(); + CORELIB_EXPORT void on_btnPlaylistsRemove_clicked(); + + CORELIB_EXPORT void on_btnPlaylistAddProj_clicked(); + CORELIB_EXPORT void on_btnPlaylistProjGoUp_clicked(); + CORELIB_EXPORT void on_btnPlaylistProjGoDown_clicked(); + CORELIB_EXPORT void on_btnPlaylistRemoveProj_clicked(); + + CORELIB_EXPORT void on_btnPlaylistsPlay_clicked(); + CORELIB_EXPORT void assignPlayPlaylistToGamepad(int idx = -1); + CORELIB_EXPORT void playPlaylist(int idx); + + CORELIB_EXPORT void reloadComboxBoxPlaylists(); + CORELIB_EXPORT void refreshListboxPorjects(); + CORELIB_EXPORT void reloadListboxPorjectsFromPlayist(); + CORELIB_EXPORT void savePlaylistProjects(); + + CORELIB_EXPORT void runDemoCommandline(); + +private: + Ui::DisplayPreferencesPanel ui; + PlaylistsLoader playlistsLoader; + QList<QString> playlistProjects; + bool playlistProjectsDirty; + int idxCurrentPlaylist; + int idxCurrentProj; +}; + +#endif // DisplayScene_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayScenePanel.cpp b/tools/ArtistTools/source/CoreLib/Window/DisplayScenePanel.cpp new file mode 100644 index 0000000..b118b6b --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayScenePanel.cpp @@ -0,0 +1,93 @@ +#include "DisplayScenePanel.h" + +#include "AppMainWindow.h" + +#include "SimpleScene.h" +#include "GlobalSettings.h" + +DisplayScenePanel::DisplayScenePanel(QWidget* parent) + : + QWidget(parent) +{ + ui.setupUi(this); +} + +void DisplayScenePanel::on_btnVisualizeWind_stateChanged(int state) +{ + GlobalSettings::Inst().m_visualizeWind = state; +} + +void DisplayScenePanel::on_btnShowGrid_stateChanged(int state) +{ + GlobalSettings::Inst().m_showGrid = state; +} + +void DisplayScenePanel::on_btnShowAxis_stateChanged(int state) +{ + GlobalSettings::Inst().m_showAxis = state; +} + +void DisplayScenePanel::on_btnShowWireframe_stateChanged(int state) +{ + GlobalSettings::Inst().m_showWireframe = state; +} + +void DisplayScenePanel::on_btnUseLighting_stateChanged(int state) +{ + GlobalSettings::Inst().m_useLighting = state; +} + +void DisplayScenePanel::on_cbRenderType_currentIndexChanged(int index) +{ + GlobalSettings::Inst().m_renderStyle = index; +} + +void DisplayScenePanel::on_btnShowHUD_stateChanged(int state) +{ + GlobalSettings::Inst().m_showHUD = state; +} + +void DisplayScenePanel::on_btnComputeStats_stateChanged(int state) +{ + GlobalSettings::Inst().m_computeStatistics = state; +} + +void DisplayScenePanel::on_btnComputeProfile_stateChanged(int state) +{ + GlobalSettings::Inst().m_computeProfile = state; +} + +void DisplayScenePanel::on_btnShowGraphicsMesh_stateChanged(int state) +{ + GlobalSettings::Inst().m_showGraphicsMesh = state; +} + +void DisplayScenePanel::on_btnShowSkinnedOnly_stateChanged(int state) +{ + GlobalSettings::Inst().m_showSkinnedMeshOnly = state; + AppMainWindow::Inst().updateUI(); +} + +void DisplayScenePanel::on_btnSkinningDQ_stateChanged(int state) +{ + GlobalSettings::Inst().m_useDQ = state; +} + +void DisplayScenePanel::on_checkBoxGizmoWithLocal_stateChanged(int state) +{ + AppMainWindow::Inst().m_bGizmoWithLocal = state; +} + +void DisplayScenePanel::updateValues() +{ + GlobalSettings& globalSettings = GlobalSettings::Inst(); + + ui.btnShowGrid->setChecked(globalSettings.m_showGrid); + ui.btnShowAxis->setChecked(globalSettings.m_showAxis); + ui.cbRenderType->setCurrentIndex(globalSettings.m_renderStyle); + ui.btnShowHUD->setChecked(globalSettings.m_showHUD); + ui.btnComputeStats->setChecked(globalSettings.m_computeStatistics); + ui.btnUseLighting->setChecked(globalSettings.m_useLighting); + ui.btnShowGraphicsMesh->setChecked( globalSettings.m_showGraphicsMesh); + ui.btnShowSkinnedOnly->setChecked( globalSettings.m_showSkinnedMeshOnly); +} diff --git a/tools/ArtistTools/source/CoreLib/Window/DisplayScenePanel.h b/tools/ArtistTools/source/CoreLib/Window/DisplayScenePanel.h new file mode 100644 index 0000000..6614eca --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/DisplayScenePanel.h @@ -0,0 +1,39 @@ +#ifndef DisplayScenePanel_h__ +#define DisplayScenePanel_h__ + +#include <QtWidgets/QWidget> +#include "ui_DisplayScenePanel.h" + +#include "corelib_global.h" + +class DisplayScenePanel : public QWidget +{ + Q_OBJECT + +public: + DisplayScenePanel(QWidget* parent); + + public: + void updateValues(); + + public slots: + CORELIB_EXPORT void on_btnVisualizeWind_stateChanged(int state); + CORELIB_EXPORT void on_btnShowGrid_stateChanged(int state); + CORELIB_EXPORT void on_btnShowAxis_stateChanged(int state); + CORELIB_EXPORT void on_cbRenderType_currentIndexChanged(int index); + CORELIB_EXPORT void on_btnShowWireframe_stateChanged(int state); + CORELIB_EXPORT void on_btnShowHUD_stateChanged(int state); + CORELIB_EXPORT void on_btnComputeStats_stateChanged(int state); + CORELIB_EXPORT void on_btnComputeProfile_stateChanged(int state); + CORELIB_EXPORT void on_btnUseLighting_stateChanged(int state); + CORELIB_EXPORT void on_btnShowGraphicsMesh_stateChanged(int state); + CORELIB_EXPORT void on_btnShowSkinnedOnly_stateChanged(int state); + CORELIB_EXPORT void on_btnSkinningDQ_stateChanged(int state); + CORELIB_EXPORT void on_checkBoxGizmoWithLocal_stateChanged(int state); + + +private: + Ui::DisplayScenePanel ui; +}; + +#endif // DisplayScene_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/ExpandablePanel.cpp b/tools/ArtistTools/source/CoreLib/Window/ExpandablePanel.cpp new file mode 100644 index 0000000..0fe96d1 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/ExpandablePanel.cpp @@ -0,0 +1,190 @@ +#include <QtWidgets/QLabel> +#include <QtGui/QImage> +#include <QtWidgets/QVBoxLayout> +#include <QtGui/QMouseEvent> +#include <QtGui/QPaintEvent> +#include <QtGui/QPainter> +#include <QtGui/QPainterPath> +#include "ExpandablePanel.h" +#include "Nv.h" + +static QImage S_TriangleRight; +static QImage S_TriangleDown; + +void InitTriangleResources(int w, int h) +{ + S_TriangleRight = QImage(w, h, QImage::Format_ARGB32); + S_TriangleDown = QImage(w, h, QImage::Format_ARGB32); + + S_TriangleRight.fill(QColor(0, 0, 0, 0)); + S_TriangleDown.fill(QColor(0, 0, 0, 0)); + + QPainter painter(&S_TriangleRight); + painter.setRenderHints(QPainter::Antialiasing,true); + + QPainterPath path; + path.moveTo(0, 0); + path.lineTo(w, h>>1); + path.lineTo(0, h); + path.lineTo(0, 0); + painter.setPen(Qt::NoPen); + painter.fillPath(path, QBrush(QColor(50, 50, 50))); + + // a painter cannot switch device? + QPainter painter2(&S_TriangleDown); + painter2.setRenderHint(QPainter::Antialiasing,true); + path = QPainterPath(); // trick to clear up a path + path.moveTo(0, 0); + path.lineTo(w, 0); + path.lineTo(w>>1, h); + path.lineTo(0, 0); + painter2.setPen(Qt::NoPen); + painter2.fillPath(path, QBrush(QColor(50, 50, 50))); +} + +class TitleLabelImpl : public TitleLabel +{ + enum + { + IMAGE_H = 10, + IMAGE_W = 10, + FIXED_H = 20, + }; + +public: + TitleLabelImpl(QWidget* parent, bool collapsed) + : TitleLabel(parent) + , _collapsed(collapsed) + { + QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed); + sizePolicy.setHorizontalStretch(0); + sizePolicy.setVerticalStretch(0); + sizePolicy.setHeightForWidth(this->sizePolicy().hasHeightForWidth()); + this->setSizePolicy(sizePolicy); + this->setMinimumSize(QSize(0, FIXED_H)); + this->setMaximumSize(QSize(16777215, FIXED_H)); + //this->setStyleSheet(QString::fromUtf8("background:rgb(219,219,219);border:1px solid rgb(185,185,185);")); + this->setFrameShape(QFrame::NoFrame); + this->setFrameShadow(QFrame::Plain); + this->setTextFormat(Qt::AutoText); + this->setScaledContents(false); + this->setAlignment(Qt::AlignCenter); + + if(S_TriangleDown.isNull() || S_TriangleRight.isNull()) + InitTriangleResources(IMAGE_W, IMAGE_H); + } + + void paintEvent(QPaintEvent * e) + { + QLabel::paintEvent(e); + + QPainter painter(this); + painter.setRenderHints(QPainter::Antialiasing,true); + + const int L = 10; + const int T = (FIXED_H - IMAGE_H)/2; + QRect rc(L, T, IMAGE_W, IMAGE_H); + + // [later] transform the painter should also work; + // but i don't get the expected results, so have to use two images + if(_collapsed) + painter.drawImage(rc, S_TriangleRight); + else + painter.drawImage(rc, S_TriangleDown); + + } + + bool Collapsed() {return _collapsed;} + void SetCollapsed(bool b) + { + _collapsed = b; + this->update(); + } + +protected: + virtual void mousePressEvent(QMouseEvent* e) + { + if(e->buttons() == Qt::LeftButton) + { + _collapsed = !_collapsed; + this->update(); + emit LPressSignal(); + } + } + +private: + bool _collapsed; +}; + +ExpandablePanel::ExpandablePanel(QWidget* parent, bool collapsed) + : QFrame(parent) + , _pContent(NV_NULL) +{ + //_pContent = new QWidget(this); + Init(collapsed); +} + +ExpandablePanel::ExpandablePanel( QWidget* content, QWidget* parent /*= 0*/ ) + : QFrame(parent) + , _pContent(content) +{ + Init(); +} + +ExpandablePanel::~ExpandablePanel() +{ + +} + +void ExpandablePanel::SetCollapsed(bool b) +{ + if (_pTitle) + _pTitle->SetCollapsed(b); +} + +void ExpandablePanel::Init(bool collapsed) +{ + setAutoFillBackground(true); + setFrameShape(QFrame::StyledPanel); + setFrameShadow(QFrame::Sunken); + _pMainLayout = new QVBoxLayout(this); + _pMainLayout->setSpacing(2); + _pMainLayout->setContentsMargins(0, 0, 0, 0); + _pMainLayout->setObjectName(QString::fromUtf8("mainLayout")); + + _pTitle = new TitleLabelImpl(this, collapsed); + _pTitle->setText("TitleLabel"); + _pMainLayout->addWidget(_pTitle); + + connect(_pTitle, SIGNAL(LPressSignal()), this, SLOT(TitlePress())); + + if(_pContent) + _pMainLayout->addWidget(_pContent); +} + +void ExpandablePanel::SetTitle( const QString& title ) +{ + _pTitle->setText(title); +} + +void ExpandablePanel::TitlePress() +{ + if(_pTitle->Collapsed()) + { + _pContent->hide(); + } + else // expanded + { + _pContent->show(); + } +} + +void ExpandablePanel::AddContent( QWidget* content ) +{ + // only support one widget as content right now + if (_pContent != NV_NULL) return; + + _pMainLayout->addWidget(content); + _pContent = content; +} + diff --git a/tools/ArtistTools/source/CoreLib/Window/ExpandablePanel.h b/tools/ArtistTools/source/CoreLib/Window/ExpandablePanel.h new file mode 100644 index 0000000..ba3018d --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/ExpandablePanel.h @@ -0,0 +1,51 @@ +#ifndef ExpandablePanel_h__ +#define ExpandablePanel_h__ + +#include <QtWidgets/QWidget> +#include <QtWidgets/QFrame> +#include <QtWidgets/QLabel> + +#include "corelib_global.h" + +class TitleLabelImpl; +class QString; +class QVBoxLayout; + +class TitleLabel : public QLabel +{ + Q_OBJECT + +public: + TitleLabel(QWidget* parent):QLabel(parent){} + +signals: + void LPressSignal(); +}; + +class ExpandablePanel : public QFrame +{ + Q_OBJECT + +public: + CORELIB_EXPORT explicit ExpandablePanel(QWidget* parent, bool collapsed = false); + explicit ExpandablePanel(QWidget* content, QWidget* parent); + virtual ~ExpandablePanel(); + + CORELIB_EXPORT void SetTitle(const QString& title); + void SetCollapsed(bool b); + QWidget* Content() {return _pContent;} + CORELIB_EXPORT void AddContent(QWidget* content); + +public slots: +CORELIB_EXPORT void TitlePress(); + +private: + void Init(bool collapsed = false); + +private: + QVBoxLayout* _pMainLayout; + TitleLabelImpl* _pTitle; + QWidget* _pContent; +}; + +#endif // ExpandablePanel_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/OutputWindow.cpp b/tools/ArtistTools/source/CoreLib/Window/OutputWindow.cpp new file mode 100644 index 0000000..08867e3 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/OutputWindow.cpp @@ -0,0 +1,22 @@ +#include "AppMainWindow.h" +#include "OutputWindow.h" + +#include <QtGUI/QContextMenuEvent> + +OutputWindow::OutputWindow(QWidget* parent) + : + QTextBrowser(parent) +{ + ui.setupUi(this); +} + +void OutputWindow::contextMenuEvent(QContextMenuEvent *event) +{ + QMenu *menu = createStandardContextMenu(); + + QAction* act = new QAction("&Clear All", this); + connect(act, SIGNAL(triggered()), this, SLOT(clear())); + menu->addAction(act); + menu->exec(event->globalPos()); + delete menu; +} diff --git a/tools/ArtistTools/source/CoreLib/Window/OutputWindow.h b/tools/ArtistTools/source/CoreLib/Window/OutputWindow.h new file mode 100644 index 0000000..5d19bb6 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/OutputWindow.h @@ -0,0 +1,22 @@ +#ifndef OutputWindow_h__ +#define OutputWindow_h__ + +#include <QtWidgets/QTextBrowser> +#include "ui_OutputWindow.h" + +#include "UIGlobal.h" + +class CORELIB_EXPORT OutputWindow : public QTextBrowser +{ + Q_OBJECT + +public: + OutputWindow(QWidget* parent); + + void contextMenuEvent(QContextMenuEvent *event); + +private: + Ui::OutputWindow ui; +}; + +#endif // DisplayScene_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/SlideSpinBox.cpp b/tools/ArtistTools/source/CoreLib/Window/SlideSpinBox.cpp new file mode 100644 index 0000000..b127f1c --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/SlideSpinBox.cpp @@ -0,0 +1,17 @@ +#include "SlideSpinBox.h" + +void SlideSpinBoxSlots::timeout() +{ + //qDebug("%s", __FUNCTION__); + this->_cb->on_timeout(); +} + +void ConfigSpinBoxInt(SlideSpinBoxInt* spinBox, int minv, int maxv, int step) +{ + spinBox->blockSignals(true); + spinBox->setRange(minv, maxv); + spinBox->setSingleStep(step); + spinBox->AutoConfigDragRange(); + spinBox->setKeyboardTracking(false); + spinBox->blockSignals(false); +} diff --git a/tools/ArtistTools/source/CoreLib/Window/SlideSpinBox.h b/tools/ArtistTools/source/CoreLib/Window/SlideSpinBox.h new file mode 100644 index 0000000..eeb7626 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/SlideSpinBox.h @@ -0,0 +1,284 @@ +#ifndef SlideSpinBox_h__ +#define SlideSpinBox_h__ + +#include <QtWidgets/QStyle> +#include <QtWidgets/QStyleOptionSpinBox> +#include <QtWidgets/QAbstractSpinBox> +#include <QtGui/QMouseEvent> +#include <QtCore/QTimer> +#include <QtWidgets/QDoubleSpinBox> +#include <QtWidgets/QSpinBox> + +#include "corelib_global.h" + +/* + A Lesson: never use a template to sub-class QWidgets! + Qt doesn't moc template widget classes; + So we have to use a specific 'slots-callback' pair to let the moc system work... + */ +class SlideSpinBoxCallback +{ +public: + virtual void on_timeout() = 0; +}; + +class SlideSpinBoxSlots : public QObject +{ + Q_OBJECT + +public: + SlideSpinBoxSlots(SlideSpinBoxCallback* cb) + : _cb (cb) + {} + + public slots: + CORELIB_EXPORT void timeout(); + +private: + SlideSpinBoxCallback* _cb; +}; + +template<typename SpinWidget, typename ValueType> +class SlideSpinBox : public SpinWidget, public SlideSpinBoxCallback +{ + +public: + void on_timeout() + { + //qDebug("%s", __FUNCTION__); + EmitDragValueChanged(); + } + +public: + typedef ValueType value_type; + + SlideSpinBox(QWidget* parent = 0) + : SpinWidget(parent) + , _dragRange(DEFAULT_DRAG_RANGE) + { + setAccelerated(true); + + ResetCustState(); + + _pSlots = new SlideSpinBoxSlots(this); + + _dragTimer.setParent(this); + _dragTimer.setInterval(DRAG_TIMER_INTERVAL); + _dragTimer.setSingleShot(true); + connect(&_dragTimer, SIGNAL(timeout()), _pSlots, SLOT(timeout())); + } + + ~SlideSpinBox() + { + delete _pSlots; + } + + void SetDragRange(int range) + { + if(range < MIN_DRAG_RANGE) + range = MIN_DRAG_RANGE; + else if(range > MAX_DRAG_RANGE) + range = MAX_DRAG_RANGE; + + _dragRange = range; + } + + void AutoConfigDragRange() + { + ValueType minv = this->minimum(); + ValueType maxv = this->maximum(); + + double vrange = maxv - minv; + double step = 1.0; + + if(vrange <= 1.0) + { + step = 0.01; + } + else if(vrange <= 10.0) + { + step = 0.1; + } + + double pixelError = 2.0; + double dragRange = vrange * pixelError / step; + + SetDragRange((int)dragRange); + } + +protected: + void mouseMoveEvent ( QMouseEvent * event ) + { + if(!_dragBegin) + { + QAbstractSpinBox::mouseMoveEvent(event); + return; + } + + if(!_dragging) + { + _dragging = true; + _cursor = this->cursor(); + + this->setCursor(Qt::SizeVerCursor); + } + + //if(_dragging) + //{ + // _dragTimer.start(); // always restart, we only need the timeout event; + //} + + event->accept(); + DragValue(event->pos()); + } + + void mousePressEvent( QMouseEvent * event ) + { + if(event->button() == Qt::LeftButton) + { + SetupCustState(event); + } + + if(_dragging) + blockSignals(true); + QAbstractSpinBox::mousePressEvent(event); + if(_dragging) + blockSignals(false); + } + + void mouseReleaseEvent( QMouseEvent * event ) + { + if(_dragging) + { + setCursor(_cursor); + _dragTimer.stop(); + } + + QAbstractSpinBox::mouseReleaseEvent(event); + //if(_dragBegin) + // EmitDragValueChanged(); + + ResetCustState(); + } + + void timerEvent(QTimerEvent *event) + { + if(_dragging) + { + // stop timer event to disable acceleration/auto-stepping + event->ignore(); + return; + } + + event->accept(); + + if(_dragBegin) blockSignals(true); + QAbstractSpinBox::timerEvent(event); + if(_dragBegin) blockSignals(false); + } + +private: + enum + { + MIN_DRAG_RANGE = 50, + MAX_DRAG_RANGE = 500, + + DEFAULT_DRAG_RANGE = 100, + + DRAG_TIMER_INTERVAL= 30, // in msec + }; + + bool SetupCustState(QMouseEvent* event) + { + QStyleOptionSpinBox opt; + this->initStyleOption(&opt); + QStyle::SubControl hitControl = this->style()->hitTestComplexControl(QStyle::CC_SpinBox, &opt, event->pos()); + if(hitControl != QStyle::SC_SpinBoxUp && hitControl != QStyle::SC_SpinBoxDown) + return false; + + _pressPosition = event->pos(); + _dragging = false; + _dragBegin = true; + _pressValue = this->value(); + _dragValue = this->value(); + + return true; + } + + void ResetCustState() + { + _dragBegin = false; + _dragging = false; + } + + void DragValue(const QPoint& pos) + { + ValueType valueRange = this->maximum() - this->minimum(); + + double dh = (double)(_pressPosition.y() - pos.y()); + double dv = valueRange * dh / (double)_dragRange; + ValueType v = _pressValue + (ValueType)dv; + + //blockSignals(true); + setValue(v); + //blockSignals(false); + } + + void EmitDragValueChanged() + { + //if(this->value() != _pressValue) // value are always bound by qt (and decimal settings) + if(this->value() != _dragValue) + { + _dragValue = this->value(); + emit valueChanged(this->value()); + } + } + + int _dragRange; + + QPoint _pressPosition; + ValueType _pressValue; + ValueType _dragValue; + + bool _dragging; + bool _dragBegin; + QCursor _cursor; + + QTimer _dragTimer; + SlideSpinBoxSlots* _pSlots; +}; + +typedef SlideSpinBox<QDoubleSpinBox, double> SlideSpinBoxF; +typedef SlideSpinBox<QSpinBox, int> SlideSpinBoxInt; + +template<typename CustSpinBox> +class ConfigSpinBox +{ +public: + typedef typename CustSpinBox::value_type ValueType; + + ConfigSpinBox(CustSpinBox* spinBox, ValueType minv, ValueType maxv, ValueType step = (ValueType)1) + { + spinBox->blockSignals(true); + spinBox->setRange(minv, maxv); + spinBox->setSingleStep(step); + spinBox->AutoConfigDragRange(); + spinBox->setKeyboardTracking(false); + SpecificConfig<ValueType>(spinBox); + spinBox->blockSignals(false); + } + + template<typename T> + void SpecificConfig(CustSpinBox* spinBox){} + + template<> + void SpecificConfig<double>(CustSpinBox* spinBox) + { + spinBox->setDecimals(2.0); + } +}; + +#include "corelib_global.h" +CORELIB_EXPORT void ConfigSpinBoxInt(SlideSpinBoxInt* spinBox, int minv, int maxv, int step = (int)1); + +#endif // SlideSpinBox_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/SlideSpinBoxInt.h b/tools/ArtistTools/source/CoreLib/Window/SlideSpinBoxInt.h new file mode 100644 index 0000000..393adee --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/SlideSpinBoxInt.h @@ -0,0 +1,15 @@ +#ifndef SlideSpinBoxInt_h__ +#define SlideSpinBoxInt_h__ + +#include <QtWidgets/QStyle> +#include <QtWidgets/QStyleOptionSpinBox> +#include <QtWidgets/QAbstractSpinBox> +#include <QtGui/QMouseEvent> +#include <QtCore/QTimer> +#include <QtWidgets/QDoubleSpinBox> +#include <QtWidgets/QSpinBox> +#include <SlideSpinBox.h> + +// use this header as a trick to make moc work right + +#endif // SlideSpinBoxInt_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/TipListView.cpp b/tools/ArtistTools/source/CoreLib/Window/TipListView.cpp new file mode 100644 index 0000000..b91fd3e --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/TipListView.cpp @@ -0,0 +1,42 @@ +#include "TipListView.h" +#include <QtWidgets/QToolTip> +#include <QtCore/QEvent> +#include <QtGUI/QEvent.h> + + +TipListView::TipListView(QWidget* parent) + :QListWidget(parent) +{ +} + +void TipListView::setTips(QStringList& tips) +{ + mTips = tips; +} + +bool TipListView::event(QEvent *evt) +{ + if (evt->type() == QEvent::ToolTip) + { + if (mTips.size() > 0) + { + QHelpEvent *helpEvent = (QHelpEvent *)(evt); + const QPoint& pos = helpEvent->pos(); + QListWidgetItem* pItem = itemAt(pos); + int index = 0, num = count(); + for (int i = 0; i < num; ++i) + { + QListWidgetItem* pi = item(i); + if (pi == pItem && mTips.size() > i) + { + QToolTip::showText(helpEvent->globalPos(), mTips[i]); + return true; + } + } + } + //QToolTip::hideText(); + //evt->ignore(); + //return true; + } + return QListWidget::event(evt); +} diff --git a/tools/ArtistTools/source/CoreLib/Window/TipListView.h b/tools/ArtistTools/source/CoreLib/Window/TipListView.h new file mode 100644 index 0000000..6913baa --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/TipListView.h @@ -0,0 +1,26 @@ +#ifndef TipListView_h__ +#define TipListView_h__ + +#include <QtWidgets/QWidget> +#include <QtWidgets/QListWidget> +#include <QtCore/QEvent> + +#include "corelib_global.h" + +class TipListView : public QListWidget +{ + Q_OBJECT + +public: + TipListView(QWidget* parent = 0); + + void setTips(QStringList& tips); + +protected: + bool event(QEvent *); +private: + + QStringList mTips; + +}; +#endif // TipListView_h__ diff --git a/tools/ArtistTools/source/CoreLib/Window/UIGlobal.h b/tools/ArtistTools/source/CoreLib/Window/UIGlobal.h new file mode 100644 index 0000000..3d50132 --- /dev/null +++ b/tools/ArtistTools/source/CoreLib/Window/UIGlobal.h @@ -0,0 +1,37 @@ +// This code contains NVIDIA Confidential Information and is disclosed +// under the Mutual Non-Disclosure Agreement. +// +// Notice +// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES +// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO +// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT, +// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. +// +// NVIDIA Corporation assumes no responsibility for the consequences of use of such +// information or for any infringement of patents or other rights of third parties that may +// result from its use. No license is granted by implication or otherwise under any patent +// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless +// expressly authorized by NVIDIA. Details are subject to change without notice. +// This code supersedes and replaces all information previously supplied. +// NVIDIA Corporation products are not authorized for use as critical +// components in life support devices or systems without express written approval of +// NVIDIA Corporation. +// +// Copyright (c) 2013-2015 NVIDIA Corporation. All rights reserved. +// +// NVIDIA Corporation and its licensors retain all intellectual property and proprietary +// rights in and to this software and related documentation and any modifications thereto. +// Any use, reproduction, disclosure or distribution of this software and related +// documentation without an express license agreement from NVIDIA Corporation is +// strictly prohibited. +// + +#pragma once + +#define USE_MATERIAL_SET 1 +#define USE_CURVE_EDITOR 0 +#define USE_TEXTURE_BRIGHTNESS 0 + +#define USE_INTERNAL_GRAPHICAL_MATERIAL 0 + +#include "corelib_global.h"
\ No newline at end of file |