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

   1 #include "StdAfx.h"
   2 #include "LodGeneratorTestAllPanel.h"
   3 #include "../UIs/ui_CLodGeneratorTestAllPanel.h"
   4 #include "qfiledialog.h"
   5 #include "LODInterface.h"
   6 #include "../Util/StringTool.h"
   7 #include <Map>
   8 #include <string>
   9
  10 using namespace LODGenerator;
  11
  12 static std::map<int,QString> ConfigMap;
  13 CLodGeneratorTestAllPanel::CLodGeneratorTestAllPanel(QWidget *parent) :
  14     QWidget(parent),
  15     ui(new Ui::CLodGeneratorTestAllPanel)
  16 {
  17     ui->setupUi(this);
  18
  19     connect(ui->SelectMeshButton, SIGNAL(clicked()), this, SLOT(SelectMeshFile_Slot()));
  20         connect(ui->SelectObjButton, SIGNAL(clicked()), this, SLOT(SelectObjFile_Slot()));
  21         //connect(ui->SelectMaterialButton, SIGNAL(clicked()), this, SLOT(SelectMaterial_Slot()));
  22
  23         connect(ui->AutoGenerateButton, SIGNAL(clicked()), this, SLOT(AutoGenerate()));
  24         connect(ui->GenerateOptionButton, SIGNAL(clicked()), this, SLOT(GenerateOption()));
  25
  26         connect(ui->GenerateConifgCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(SelectConfig_Slot(int)));
  27
  28         connect(this,SIGNAL(SelectMeshFile_Signal(const QString)),ui->SelectMeshPathEdit,SLOT(setText(const QString)));
  29         //connect(this,SIGNAL(SelectMateralFile_Signal(const QString)),ui->SelectMaterialPathEdit,SLOT(setText(const QString)));
  30
  31         //-------------------------------------------------------------------------------------------------------------
  32
  33         connect(this,SIGNAL(UpdateProgress_Signal(int)),ui->AutoGenerateProgress,SLOT(setValue(int)));
  34
  35
  36         m_LodGeneratorState = Ui::eLGS_None;
  37
  38         UpdateProgress_Signal(0);
  39
  40         m_LodGeneratorOptionsPanel = new CLodGeneratorOptionsPanel(NULL);
  41         m_LodGeneratorOptionsPanel->hide();
  42
  43         ConfigMap[6] = "Six Lods";
  44         ConfigMap[5] = "Five Lods";
  45         ConfigMap[4] = "Four Lods";
  46         ConfigMap[3] = "Tree Lods";
  47         ConfigMap[2] = "Two Lods";
  48         ConfigMap[1] = "One Lods";
  49         ConfigMap[0] = "No Lods";
  50
  51         for (int i=0;i<ConfigMap.size();i++)
  52         {
  53                 ui->GenerateConifgCombo->addItem(ConfigMap[i]);
  54         }
  55
  56         //-------------------------------------------------------------------------------------------------------------
  57 }
  58
  59 CLodGeneratorTestAllPanel::~CLodGeneratorTestAllPanel()
  60 {
  61     delete ui;
  62
  63         if (m_LodGeneratorOptionsPanel != NULL)
  64                 delete m_LodGeneratorOptionsPanel;
  65 }
  66
  67 void CLodGeneratorTestAllPanel::UpdateConfig()
  68 {
  69         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
  70         const int nLods = pInstance->NumberOfLods();
  71         if(nLods >=1 && nLods <= ConfigMap.size())
  72                 ui->GenerateConifgCombo->setCurrentIndex(nLods - 1);
  73 }
  74
  75 void CLodGeneratorTestAllPanel::SelectConfig_Slot(int index)
  76 {
  77         m_LodInfoList.clear();
  78         int allCount = index;
  79         for (int i=0;i<allCount;i++)
  80         {
  81                 int level = pow(2,i+1);
  82                 Ui::LodInfo lodInfo;
  83                 lodInfo.percentage = 100.0/level;
  84                 lodInfo.width = 2048/level;
  85                 lodInfo.height = 2048/level;
  86                 m_LodInfoList.push_back(lodInfo);
  87         }
  88 }
  89
  90 void CLodGeneratorTestAllPanel::SetState(Ui::ELodGeneratorState lodGeneratorState)
  91 {
  92         m_LodGeneratorState = lodGeneratorState;
  93 }
  94
  95 void CLodGeneratorTestAllPanel::ShowMessage(std::string message)
  96 {
  97         CryLog("Lod Generator Auto: %s",message.c_str());
  98         //ui->MessageShow->append(message);
  99 }
 100
 101 void CLodGeneratorTestAllPanel::SelectMaterial_Slot()
 102 {
 103         setCursor(QCursor(Qt::WaitCursor));
 104         CLodGeneratorInteractionManager::Instance()->OpenMaterialEditor();
 105         setCursor(QCursor(Qt::ArrowCursor));
 106 }
 107
 108 void CLodGeneratorTestAllPanel::SelectMeshFile_Slot()
 109 {
 110     m_MeshPath = QFileDialog::getOpenFileName(this,  tr("Select File"),  "",  tr("Mesh (*.cgf)"));
 111         CString material(CLodGeneratorInteractionManager::Instance()->GetDefaultBrushMaterial(CStringTool::QStringToCString(m_MeshPath)));
 112
 113     SelectMeshFile_Signal(m_MeshPath);
 114         SelectMateralFile_Signal(CStringTool::CStringToQString(material));
 115
 116         FileOpened();
 117
 118         UpdateConfig();
 119 }
 120
 121 bool CLodGeneratorTestAllPanel::FileOpened()
 122 {
 123         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 124         CString filepath(CStringTool::QStringToCString(LoadedFile()));
 125         if(!pInstance->LoadStatObj(filepath))
 126         {
 127                 CryMessageBox("Failed to load file into the engine, please consult the editor.log","File Load Failed",0);
 128                 return false;
 129         }
 130
 131         CString materialpath(CStringTool::QStringToCString(MaterialFile()));
 132         if(!pInstance->LoadMaterial(materialpath))
 133         {
 134                 CryMessageBox("Failed to load material file into the engine, please consult the editor.log","File Load Failed",0);
 135                 return false;
 136         }
 137
 138         return TRUE;
 139 }
 140
 141 void CLodGeneratorTestAllPanel::AutoGenerate()
 142 {
 143         TaskStarted();
 144         SetState(Ui::eLGS_GeneratePreparePre);
 145 }
 146
 147 void CLodGeneratorTestAllPanel::GenerateOption()
 148 {
 149         if (m_LodGeneratorOptionsPanel->isHidden())
 150         {
 151                 m_LodGeneratorOptionsPanel->show();
 152         }
 153         else
 154         {
 155                 m_LodGeneratorOptionsPanel->hide();
 156         }
 157 }
 158
 159 void CLodGeneratorTestAllPanel::TaskStarted()
 160 {
 161         m_nTimerId = startTimer(1000);
 162 }
 163
 164 void CLodGeneratorTestAllPanel::TaskFinished()
 165 {
 166         if ( m_nTimerId != 0 )
 167                 killTimer(m_nTimerId);
 168         m_nTimerId = 0;
 169 }
 170
 171 void CLodGeneratorTestAllPanel::timerEvent( QTimerEvent *event )
 172 {
 173         switch (m_LodGeneratorState)
 174         {
 175         case Ui::eLGS_GeneratePreparePre:
 176                 {
 177                         ShowMessage("Before Generate Pre Prepare");
 178                         CLodGeneratorInteractionManager::Instance()->LodGenGenerate();
 179                         m_StartTime = QTime::currentTime();
 180                         SetState(Ui::eLGS_GeneratePrepare);
 181                         ShowMessage("After Generate Pre Prepare");
 182                         ShowMessage("Before Generate Prepare");
 183
 184                         UpdateProgress_Signal(0);
 185                 }
 186                 break;
 187         case Ui::eLGS_GeneratePrepare:
 188                 {
 189                         float fProgress = 0.0f;
 190                         float fProgressPercentage = 0.0f;
 191                         QString text;
 192                         bool bFinished = false;
 193
 194                         if ( CLodGeneratorInteractionManager::Instance()->LodGenGenerateTick(&fProgress) )
 195                         {
 196                                 text = "Finished!";
 197                                 bFinished = true;
 198                                 SetState(Ui::eLGS_GenerateMesh);
 199                         }
 200                         else
 201                         {
 202                                 bFinished = false;
 203                                 fProgressPercentage = 100.0f*fProgress;
 204                                 if ( fProgressPercentage == 0.0f )
 205                                 {
 206                                         text = "Estimating...";
 207                                 }
 208                                 else
 209                                 {
 210                                         QTime time = QTime::currentTime();
 211
 212                                         float fExpendedTime = (time.msecsSinceStartOfDay() - m_StartTime.msecsSinceStartOfDay())/1000.0f;
 213                                         float fTotalSeconds = (fExpendedTime / fProgressPercentage) * 100.0f;
 214                                         float fTimeLeft = fTotalSeconds - fExpendedTime;
 215                                         int hours = (int)(fTimeLeft / (60.0f *60.0f));
 216                                         fTimeLeft -= hours * (60.0f *60.0f);
 217                                         int Minutes = (int)(fTimeLeft / 60.0f);
 218                                         int Seconds = (((int)fTimeLeft) % 60);
 219                                         text = QString("ETA %1 Hours %2 Minutes %3 Seconds Remaining").arg(QString::number(hours),QString::number(Minutes),QString::number(Seconds));
 220                                 }
 221
 222                                 UpdateProgress_Signal(80.0f*fProgress);
 223                         }
 224                 }
 225                 break;
 226         case Ui::eLGS_GenerateMesh:
 227                 {
 228                         ShowMessage("After Generate Prepare");
 229                         ShowMessage("Before Generate Mesh");
 230                         OnGenerateMeshs();
 231                         SetState(Ui::eLGS_GenerateMaterial);
 232                         ShowMessage("After Generate Mesh");
 233                         UpdateProgress_Signal(85);
 234                 }
 235                 break;
 236         case Ui::eLGS_GenerateMaterial:
 237                 {
 238                         ShowMessage("Before Generate Material");
 239                         OnGenerateMaterials();
 240                         SetState(Ui::eLGS_None);
 241                         ShowMessage("After Generate Material");
 242                         UpdateProgress_Signal(100);
 243                 }
 244                 break;
 245         case Ui::eLGS_None:
 246                 {
 247                         TaskFinished();
 248                         ShowMessage("Generate All Done");
 249                 }
 250                 break;
 251         default:
 252                 break;
 253         }
 254 }
 255
 256 void CLodGeneratorTestAllPanel::OnGenerateMeshs()
 257 {
 258         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 259         int highestLod = pInstance->GetHighestLod();
 260
 261         if ( highestLod > 0 )
 262         {
 263                 if ( CryMessageBox("Lods already exist for this model, generating will overwrite any existing lods.","Overwrite existing lods?",MB_OKCANCEL) == IDCANCEL )
 264                 {
 265                 }
 266         }
 267
 268         const int lods = m_LodInfoList.size();
 269
 270         pInstance->ClearUnusedLods(lods);
 271
 272         int nSourceLod = pInstance->GetGeometryOption<int>("nSourceLod");
 273         for ( int idx = 1; idx <= lods ; ++idx )
 274         {
 275                 Ui::LodInfo& lodInfo = m_LodInfoList[idx - 1];
 276                 pInstance->GenerateLod(nSourceLod+idx,lodInfo.percentage);
 277                 lodInfo.lod = idx;
 278         }
 279         pInstance->SaveSettings();
 280         pInstance->ReloadModel();
 281 }
 282
 283
 284 void CLodGeneratorTestAllPanel::OnGenerateMaterials()
 285 {
 286         CLodGeneratorInteractionManager::Instance()->ClearResults();
 287         const int nNumLods = m_LodInfoList.size();
 288         for (int idx = 0; idx < nNumLods; ++idx)
 289         {
 290                 Ui::LodInfo& lodInfo = m_LodInfoList[idx];
 291                 int nLodId = lodInfo.lod;
 292                 int nWidth = lodInfo.width;
 293                 int nHeight = lodInfo.height;
 294
 295                 CLodGeneratorInteractionManager::Instance()->RunProcess(nLodId,nWidth,nHeight);
 296         }
 297
 298         for (int idx = 0; idx < nNumLods; ++idx)
 299         {
 300                 Ui::LodInfo& lodInfo = m_LodInfoList[idx];
 301                 int nLodId = lodInfo.lod;
 302                 CLodGeneratorInteractionManager::Instance()->SaveTextures(nLodId);
 303         }
 304
 305         CLodGeneratorInteractionManager::Instance()->ClearResults();
 306 }
 307
 308 void CLodGeneratorTestAllPanel::OnOpenWithPathParameter(const QString& objectPath )
 309 {
 310         if(!objectPath.isEmpty())
 311         {
 312                 CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 313                 m_MaterialPath = CStringTool::CStringToQString(pInstance->GetDefaultBrushMaterial(CStringTool::QStringToCString(objectPath)));
 314
 315                 m_MeshPath = objectPath;
 316
 317                 SelectMeshFile_Signal(m_MeshPath);
 318                 SelectMateralFile_Signal(m_MaterialPath);
 319
 320                 pInstance->SetParameterFilePath("");
 321         }
 322 }
 323
 324 void CLodGeneratorTestAllPanel::SelectObjFile_Slot()
 325 {
 326         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 327         CString filepath(pInstance->GetParameterFilePath());
 328
 329         if( filepath.IsEmpty() )
 330                 filepath = pInstance->GetSelectedBrushFilepath();
 331         else
 332         {
 333                 OnOpenWithPathParameter(CStringTool::CStringToQString(pInstance->GetParameterFilePath()));
 334                 return;
 335         }
 336
 337         if ( filepath.IsEmpty() )
 338                 return;
 339
 340         setCursor(QCursor(Qt::WaitCursor));
 341
 342         m_MeshPath = CStringTool::CStringToQString(filepath);
 343         m_MaterialPath = CStringTool::CStringToQString(pInstance->GetSelectedBrushMaterial());
 344
 345         SelectMeshFile_Signal(m_MeshPath);
 346         SelectMateralFile_Signal(m_MaterialPath);
 347
 348         FileOpened();
 349
 350         setCursor(QCursor(Qt::ArrowCursor));
 351
 352         UpdateConfig();
 353 }
 354
 355 const QString CLodGeneratorTestAllPanel::LoadedFile()
 356 {
 357         return m_MeshPath;
 358 }
 359
 360 const QString CLodGeneratorTestAllPanel::MaterialFile()
 361 {
 362         return m_MaterialPath;
 363 }
 364
 365 const void CLodGeneratorTestAllPanel::RefreshMaterialFile()
 366 {
 367         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
 368
 369         setCursor(QCursor(Qt::WaitCursor));
 370         m_MaterialPath = CStringTool::CStringToQString(CLodGeneratorInteractionManager::Instance()->GetDefaultBrushMaterial(CStringTool::QStringToCString(m_MeshPath)));
 371
 372         SelectMateralFile_Signal(m_MaterialPath);
 373         setCursor(QCursor(Qt::ArrowCursor));
 374 }
 375
 376 void CLodGeneratorTestAllPanel::Reset()
 377 {
 378
 379 }