Code/Sandbox/Plugins/LodGeneratorPlugin/panel/LodGeneratorDialog.cpp

   1 #include "StdAfx.h"
   2 #include "LodGeneratorDialog.h"
   3 #include "../UIs/ui_clodgeneratordialog.h"
   4 #include "LODInterface.h"
   5 #include "../Util/StringTool.h"
   6 #include "Controls/QuestionDialog.h"
   7 #include "QtViewPane.h"
   8
   9 using namespace LODGenerator;
  10
  11 REGISTER_VIEWPANE_FACTORY(CLodGeneratorDialog, "Lod Generator", "Tools", false);
  12
  13 CLodGeneratorDialog::CLodGeneratorDialog(QWidget *parent) :
  14     CDockableEditor(parent),
  15     ui(new Ui::CLodGeneratorDialog)
  16 {
  17     ui->setupUi(this);
  18
  19         connect(ui->cSourceFileWidget, SIGNAL(FileOpened_Signal()), this, SLOT(FileOpened()));
  20         connect(ui->cSourceFileWidget, &CLodGeneratorFilePanel::MaterialChanged_Signal, this, &CLodGeneratorDialog::OnMaterialChange);
  21         connect(ui->cGeometryGenerationPanelWidget,SIGNAL(OnMaterialGeneratePrepare_Signal()),this,SLOT(OnMaterialGeneratePrepare()));
  22         connect(this,SIGNAL(UpdateObj_Signal(IStatObj*)),ui->cGeometryGenerationPanelWidget,SLOT(UpdateObj(IStatObj*)));
  23         connect(this,SIGNAL(UpdateMaterial_Signal(IMaterial*)),ui->cGeometryGenerationPanelWidget,SLOT(UpdateMaterial(IMaterial*)));
  24         connect(ui->cMaterialTaskWidget,SIGNAL(OnGenerateMaterial()),this,SLOT(OnGenerateMaterial()));
  25
  26         connect(ui->cGeometryTaskPanelWidget,SIGNAL(OnLodChainGenerationFinished()),ui->cGeometryGenerationPanelWidget,SLOT(OnLodChainGenerationFinished()));
  27
  28         connect(ui->centralWidget,SIGNAL(OnGenerateMaterial()),this,SLOT(OnGenerateMaterial()));
  29
  30         GetIEditor()->RegisterNotifyListener(this);
  31 }
  32
  33 CLodGeneratorDialog::~CLodGeneratorDialog()
  34 {
  35     delete ui;
  36
  37         GetIEditor()->UnregisterNotifyListener(this);
  38 }
  39
  40 void CLodGeneratorDialog::OnEditorNotifyEvent( EEditorNotifyEvent event )
  41 {
  42         switch( event )
  43         {
  44         case eNotify_OnIdleUpdate:
  45                 {
  46                         ui->cGeometryGenerationPanelWidget->OnIdle();
  47                         for (int  i =0;i<ui->m_vLodPanels.size();i++)
  48                         {
  49                                 CMaterialLODGeneratorLodItemOptionsPanel* pPanel = ui->m_vLodPanels[i];
  50                                 pPanel->OnIdle();
  51                         }
  52                 }
  53
  54                 break;
  55
  56         }
  57
  58 }
  59
  60 void CLodGeneratorDialog::OnTextureSizeChanged(int nWidth, int nHeight)
  61 {
  62         int curWidth = nWidth;
  63         int curHeight = nHeight;
  64
  65         const int nNumLods = ui->m_vLodPanels.size();
  66         for (int idx = 1; idx < nNumLods; ++idx)
  67         {
  68                 curWidth = curWidth/2;
  69                 curHeight = curHeight/2;
  70                 ui->m_vLodPanels[idx]->SetTextureSize(curWidth,curHeight);
  71         }
  72 }
  73
  74 void CLodGeneratorDialog::Reset(bool value)
  75 {
  76         //ClearLodPanels();
  77
  78         ui->cSourceFileWidget->Reset();
  79         ui->cGeometryBakeOptonsWidge->Reset();
  80         ui->cMaterialBakeOptionsWidget->Reset();
  81         ui->cGeometryTaskPanelWidget->Reset();
  82         ui->cGeometryGenerationPanelWidget->Reset();
  83
  84         CLodGeneratorInteractionManager::Instance()->ResetSettings();
  85
  86         ui->cGeometryBakeOptonsWidge->Update();
  87         ui->cMaterialBakeOptionsWidget->Update();
  88
  89         //if(m_pMatOptionsPanel)
  90         //      m_pMatOptionsPanel->Update();
  91 }
  92
  93 bool CLodGeneratorDialog::FileOpened()
  94 {
  95         Reset(true);
  96
  97         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
  98         string filepath(CStringTool::QStringToCString(ui->cSourceFileWidget->LoadedFile()));
  99         if (!pInstance->LoadStatObj(filepath))
 100         {
 101                 CQuestionDialog::SWarning("File Load Failed", "Failed to load file into the engine, please consult the editor.log");
 102                 return false;
 103         }
 104
 105         ui->cSourceFileWidget->RefreshMaterialFile();
 106
 107         return LoadMaterialHelper(ui->cSourceFileWidget->MaterialFile());
 108 }
 109
 110 bool CLodGeneratorDialog::OnMaterialChange(const QString& materialPath)
 111 {
 112         if (LoadMaterialHelper(materialPath))
 113         {
 114                 CLodGeneratorInteractionManager::Instance()->UpdateFilename(CStringTool::QStringToCString(materialPath));
 115                 return true;
 116         }
 117         return false;
 118 }
 119
 120 bool CLodGeneratorDialog::LoadMaterialHelper(const QString& materialPath)
 121 {
 122         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 123         if(!pInstance->LoadMaterial(CStringTool::QStringToCString(materialPath)))
 124         {
 125                 CQuestionDialog::SWarning("File Load Failed", "Failed to load material file into the engine, please consult the editor.log");
 126                 return false;
 127         }
 128
 129         ui->cGeometryGenerationPanelWidget->CreateExistingLodKeys();
 130         OnMaterialGeneratePrepare();
 131         ui->cGeometryBakeOptonsWidge->Update();
 132         ui->cMaterialBakeOptionsWidget->Update();
 133
 134         UpdateObj_Signal(pInstance->GetLoadedModel());
 135
 136         return true;
 137 }
 138
 139 void CLodGeneratorDialog::ClearLodPanels()
 140 {
 141         for each (CMaterialLODGeneratorLodItemOptionsPanel* pPanel in ui->m_vLodPanelParents)
 142         {
 143                 int index = ui->LodGeneratorToolBox->indexOf(pPanel);
 144                 if(index >= 0)
 145                         ui->LodGeneratorToolBox->removeItem(index);
 146         }
 147         ui->m_vLodPanelsIdx.clear();
 148         ui->m_vLodPanels.clear();
 149         ui->m_vLodPanelParents.clear();
 150 }
 151
 152
 153 void CLodGeneratorDialog::GenerateLodPanels()
 154 {
 155         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 156         if (!pInstance)
 157                 return;
 158
 159         int     nSourceLod = pInstance->GetGeometryOption<int>("nSourceLod");
 160
 161         const int nLods = pInstance->NumberOfLods();
 162         for (int idx = nSourceLod+1; idx < nLods; ++idx)
 163         {
 164                 int nLodIdx = idx;
 165                 int nSubmatIdx = pInstance->GetSubMatId(nLodIdx);
 166                 bool bAllowTextureSizeControl = idx == nSourceLod+1;
 167                 CMaterialLODGeneratorLodItemOptionsPanel* pItemPanel = new CMaterialLODGeneratorLodItemOptionsPanel();
 168                 pItemPanel->SetParams(nLodIdx,nSubmatIdx,bAllowTextureSizeControl);
 169                 if(bAllowTextureSizeControl)
 170                         connect(pItemPanel,SIGNAL(OnTextureSizeChanged(int,int)),this,SLOT(OnTextureSizeChanged(int,int)));
 171                 if (!pItemPanel)
 172                         continue;
 173
 174                 string panelName;
 175                 panelName.Format(CMaterialLODGeneratorLodItemOptionsPanel::kPanelCaption,idx);
 176
 177                 //---------------------------------------------------------------------------------------------------
 178
 179                 QWidget* SourceFileWidget = new QWidget();
 180                 //SourceFileWidget->setObjectName(QStringLiteral("SourceFileWidget"));
 181                 SourceFileWidget->setGeometry(QRect(0, 0, 437, 411));
 182                 QVBoxLayout* verticalLayout = new QVBoxLayout(SourceFileWidget);
 183                 verticalLayout->setSpacing(6);
 184                 verticalLayout->setContentsMargins(11, 11, 11, 11);
 185                 verticalLayout->setObjectName(QStringLiteral("verticalLayout"));
 186                 verticalLayout->setContentsMargins(0, 0, 0, 0);
 187 //              cSourceFileWidget = new CLodGeneratorFilePanel(SourceFileWidget);
 188 //              cSourceFileWidget->setObjectName(QStringLiteral("cSourceFileWidget"));
 189                 QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 190                 sizePolicy.setHorizontalStretch(0);
 191                 sizePolicy.setVerticalStretch(0);
 192                 sizePolicy.setHeightForWidth(pItemPanel->sizePolicy().hasHeightForWidth());
 193                 pItemPanel->setSizePolicy(sizePolicy);
 194                 QHBoxLayout* horizontalLayout = new QHBoxLayout(pItemPanel);
 195                 horizontalLayout->setSpacing(6);
 196                 horizontalLayout->setContentsMargins(11, 11, 11, 11);
 197                 horizontalLayout->setObjectName(QStringLiteral("horizontalLayout"));
 198                 horizontalLayout->setContentsMargins(0, 0, 0, 0);
 199
 200                 verticalLayout->addWidget(pItemPanel);
 201
 202                 QSpacerItem* verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding);
 203
 204                 verticalLayout->addItem(verticalSpacer);
 205
 206
 207                 //---------------------------------------------------------------------------------------------------
 208
 209                 int index = ui->LodGeneratorToolBox->addItem(SourceFileWidget,CStringTool::CStringToQString(panelName));
 210
 211                 ui->m_vLodPanelsIdx.push_back(index);
 212                 ui->m_vLodPanels.push_back(pItemPanel);
 213                 ui->m_vLodPanelParents.push_back(SourceFileWidget);
 214         }
 215
 216         for (int idx = 1; idx < nLods; idx++)
 217         {
 218                 const int nSubMats = pInstance->GetSubMatCount(idx);
 219                 if (nSubMats > 1)
 220                 {
 221                         CQuestionDialog::SWarning("LOD Sub-Material Warning", "Loaded lods have multiple sub-materials please ensure only a single material is used before attempting to bake texture materials");
 222                         break;
 223                 }
 224         }
 225 }
 226
 227
 228 void CLodGeneratorDialog::OnMaterialGeneratePrepare()
 229 {
 230         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 231         if(!pInstance->GetLoadedModel())
 232                 return;
 233
 234         ClearLodPanels();
 235         GenerateLodPanels();
 236         ui->cMaterialBakeOptionsWidget->Update();
 237
 238         XmlNodeRef settings = pInstance->GetSettings("MaterialLodSettings");
 239         const int individualLodChildSettings = settings->getChildCount();
 240         for (int idx = 0; idx < individualLodChildSettings; ++idx)
 241         {
 242                 XmlNodeRef child = settings->getChild(idx);
 243                 int nLodId = -1;
 244                 if (!child->getAttr("nLodId",nLodId))
 245                         break;
 246
 247                 const int nNumLods = ui->m_vLodPanels.size();
 248                 for (int panelidx = 0; panelidx < nNumLods; ++panelidx)
 249                 {
 250                         if ( ui->m_vLodPanels[panelidx]->LodId() == nLodId)
 251                         {
 252                                  ui->m_vLodPanels[panelidx]->Serialize(child,true);
 253                                 break;
 254                         }
 255                 }
 256         }
 257
 258         return;
 259 }
 260
 261
 262 bool CLodGeneratorDialog::OnGenerateMaterial()
 263 {
 264         CWaitCursor wait;
 265         CLodGeneratorInteractionManager::Instance()->ClearResults();
 266         const int nNumLods = ui->m_vLodPanels.size();
 267         for (int idx = 0; idx < nNumLods; ++idx)
 268         {
 269                 CMaterialLODGeneratorLodItemOptionsPanel* pPanel = ui->m_vLodPanels[idx];
 270                 if (!pPanel->IsBakingEnabled())
 271                         continue;
 272
 273                 int nLodId = pPanel->LodId();
 274                 int nWidth = pPanel->Width();
 275                 int nHeight = pPanel->Height();
 276
 277                 CLodGeneratorInteractionManager::Instance()->RunProcess(nLodId,nWidth,nHeight);
 278                 pPanel->UpdateUITextures();
 279         }
 280         OnSave();
 281         CLodGeneratorInteractionManager::Instance()->ClearResults();
 282
 283         return TRUE;
 284 }
 285
 286
 287 bool CLodGeneratorDialog::OnSave()
 288 {
 289         CWaitCursor wait;
 290         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 291
 292         const int nNumLods = ui->m_vLodPanels.size();
 293         for (int idx = 0; idx < nNumLods; ++idx)
 294         {
 295                 CMaterialLODGeneratorLodItemOptionsPanel* pPanel = ui->m_vLodPanels[idx];
 296                 if (!pPanel->IsBakingEnabled())
 297                         continue;
 298
 299                 int nLodId = pPanel->LodId();
 300                 pInstance->SaveTextures(nLodId);
 301         }
 302
 303         ui->cMaterialBakeOptionsWidget->Update();
 304
 305         XmlNodeRef settings = pInstance->GetSettings("MaterialLodSettings");
 306         settings->removeAllChilds();
 307         for (int idx = 0; idx < nNumLods; ++idx)
 308         {
 309                 CMaterialLODGeneratorLodItemOptionsPanel* pPanel = ui->m_vLodPanels[idx];
 310                 pPanel->Serialize(settings,false);
 311         }
 312
 313         // update panel material,cause of reloading
 314         for (int idx = 0; idx < nNumLods; ++idx)
 315         {
 316                 CMaterialLODGeneratorLodItemOptionsPanel* pPanel = ui->m_vLodPanels[idx];
 317                 pPanel->UpdateMaterial();
 318         }
 319
 320         pInstance->SaveSettings();
 321         return true;
 322 }
 323
 324 const char* CLodGeneratorDialog::GetEditorName() const
 325 {
 326         return "LOD Generator";
 327 }