Code/Sandbox/Plugins/MaterialEditorPlugin/MaterialEditor.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2 #include "StdAfx.h"
   3 #include "MaterialEditor.h"
   4
   5 #include <AssetSystem/Asset.h>
   6 #include <AssetSystem/EditableAsset.h>
   7 #include <PathUtils.h>
   8
   9 #include <EditorFramework/Events.h>
  10 #include <EditorFramework/Inspector.h>
  11 #include <LevelEditor/LevelEditorSharedState.h>
  12
  13 #include "SubMaterialView.h"
  14 #include "MaterialPreview.h"
  15 #include "MaterialProperties.h"
  16 #include "PickMaterialTool.h"
  17
  18 #include "Dialogs/QNumericBoxDialog.h"
  19
  20 #include "IUndoObject.h"
  21
  22 #include <CryCore/CryTypeInfo.h>
  23
  24 #include <QHBoxLayout>
  25 #include <QLabel>
  26 #include <QLineEdit>
  27 #include <QToolButton>
  28
  29 namespace Private_MaterialEditor
  30 {
  31
  32 REGISTER_VIEWPANE_FACTORY(CMaterialEditor, "Material Editor", "Tools", false);
  33
  34 class CSession : public IAssetEditingSession
  35 {
  36 public:
  37         CSession(CMaterial* pMaterial) : m_pMaterial(pMaterial) {}
  38
  39         virtual const char* GetEditorName() const override
  40         {
  41                 return "Material Editor";
  42         }
  43
  44         virtual bool OnSaveAsset(IEditableAsset& asset) override
  45         {
  46                 if (!m_pMaterial || !m_pMaterial->Save(false))
  47                 {
  48                         return false;
  49                 }
  50
  51                 //Fill metadata and dependencies to update cryasset file
  52                 asset.SetFiles({ m_pMaterial->GetFilename() });
  53
  54                 std::vector<SAssetDependencyInfo> filenames;
  55
  56                 //TODO : not all dependencies are found, some paths are relative to same folder which is not good ...
  57                 int textureCount = m_pMaterial->GetTextureDependencies(filenames);
  58
  59                 std::vector<std::pair<string, string>> details;
  60                 details.push_back(std::pair<string, string>("subMaterialCount", ToString(m_pMaterial->GetSubMaterialCount())));
  61                 details.push_back(std::pair<string, string>("textureCount", ToString(textureCount)));
  62
  63                 asset.SetDetails(details);
  64                 asset.SetDependencies(filenames);
  65                 return true;
  66         }
  67
  68         virtual void DiscardChanges(IEditableAsset& asset) override
  69         {
  70                 if (!m_pMaterial)
  71                 {
  72                         return;
  73                 }
  74
  75                 m_pMaterial->Reload();
  76         }
  77
  78         virtual bool OnCopyAsset(INewAsset& asset) override
  79         {
  80                 CMaterial* pMaterial = GetIEditor()->GetMaterialManager()->DuplicateMaterial(PathUtil::Make(asset.GetFolder(), asset.GetName()), m_pMaterial);
  81                 CSession session(pMaterial);
  82                 return session.OnSaveAsset(asset);
  83         }
  84
  85         static CMaterial* GetSessionMaterial(CAsset* pAsset)
  86         {
  87                 IAssetEditingSession* pSession = pAsset->GetEditingSession();
  88                 if (!pSession || strcmp(pSession->GetEditorName(), "Material Editor") != 0)
  89                 {
  90                         return nullptr;
  91                 }
  92                 return static_cast<CSession*>(pSession)->GetMaterial();
  93         }
  94
  95 private:
  96         CMaterial* GetMaterial() { return m_pMaterial; }
  97
  98         _smart_ptr<CMaterial> m_pMaterial;
  99 };
 100
 101 }
 102
 103 CMaterialEditor::CMaterialEditor()
 104         : CAssetEditor("Material")
 105         , m_pMaterial(nullptr)
 106 {
 107         InitMenuBar();
 108         CreateToolbar();
 109         EnableDockingSystem();
 110
 111         RegisterDockableWidget("Properties", [&]()
 112         {
 113                 CInspector* pInspector = new CInspector(this);
 114                 pInspector->SetLockable(false);
 115                 return pInspector;
 116         }, true);
 117
 118         RegisterDockableWidget("Material", [&]() { return new CSubMaterialView(this); }, true);
 119         RegisterDockableWidget("Preview", [&]() { return new CMaterialPreviewWidget(this); });
 120
 121         GetIEditor()->GetMaterialManager()->AddListener(this);
 122 }
 123
 124 void CMaterialEditor::CreateToolbar()
 125 {
 126         const auto pToolbar = new QWidget;
 127         const auto pSpacer = new QWidget();
 128         pSpacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 129         auto toolbarLayout = new QHBoxLayout(pToolbar);
 130         toolbarLayout->addWidget(pSpacer);
 131         toolbarLayout->addWidget(CreateInstantEditorToolbar());
 132         toolbarLayout->setContentsMargins(0, 0, 0, 0);
 133
 134         QVBoxLayout* pMainLayout = new QVBoxLayout();
 135         pMainLayout->setContentsMargins(1, 1, 1, 1);
 136         pMainLayout->addWidget(pToolbar);
 137         SetContent(pMainLayout);
 138 }
 139
 140 CMaterialEditor::~CMaterialEditor()
 141 {
 142         GetIEditor()->GetMaterialManager()->RemoveListener(this);
 143 }
 144
 145 void CMaterialEditor::InitMenuBar()
 146 {
 147         AddToMenu(CEditor::MenuItems::SaveAs);
 148         AddToMenu(CEditor::MenuItems::EditMenu);
 149         AddToMenu(CEditor::MenuItems::Undo);
 150         AddToMenu(CEditor::MenuItems::Redo);
 151
 152         CAbstractMenu* pFileMenu = GetMenu(CEditor::MenuItems::FileMenu);
 153         QAction* pAction = pFileMenu->CreateAction(CryIcon("icons:General/Picker.ico"), tr("Pick Material From Scene"), 0, 1);
 154         connect(pAction, &QAction::triggered, this, &CMaterialEditor::OnPickMaterial);
 155
 156         //Add a material actions menu
 157         //TODO: consider adding a toolbar for material actions
 158         CAbstractMenu* materialMenu = GetRootMenu()->CreateMenu(tr("Material"), 0, 3);
 159         materialMenu->signalAboutToShow.Connect(this, &CMaterialEditor::FillMaterialMenu);
 160
 161         // Enable instant editing if possible
 162         CAbstractMenu* const pEditMenu = GetMenu(CEditor::MenuItems::EditMenu);
 163         pEditMenu->AddCommandAction(m_pLockAction);
 164 }
 165
 166 void CMaterialEditor::OnEditorNotifyEvent(EEditorNotifyEvent event)
 167 {
 168         switch (event)
 169         {
 170         case eNotify_OnEndSceneOpen:
 171         case eNotify_OnEndNewScene:
 172                 //HACK : Due to the questionable behavior of material manager, which clears itself when the level is loaded
 173                 //The materials used in the scene (and the material editor) will be recreated after the scene is loaded,
 174                 //making the material editor appear to be not in sync. A quick hack is to reload from filename, to get the updated material.
 175                 if (GetAssetBeingEdited())
 176                 {
 177                         OnOpenAsset(GetAssetBeingEdited());
 178                 }
 179         }
 180 }
 181
 182 void CMaterialEditor::OnDataBaseItemEvent(IDataBaseItem* pItem, EDataBaseItemEvent event)
 183 {
 184         if (!pItem || !m_pMaterial || event == EDB_ITEM_EVENT_SELECTED)
 185                 return;
 186
 187         CMaterial* item = (CMaterial*)pItem;
 188
 189         if (pItem == m_pMaterial.get())
 190         {
 191                 switch (event)
 192                 {
 193                 case EDB_ITEM_EVENT_CHANGED:
 194                 case EDB_ITEM_EVENT_UPDATE_PROPERTIES:
 195                         signalMaterialPropertiesChanged(item);
 196                         if (GetAssetBeingEdited())
 197                         {
 198                                 GetAssetBeingEdited()->SetModified(true);
 199                         }
 200                         break;
 201                 case EDB_ITEM_EVENT_DELETE:
 202                         //Note: this happens on loading of the level. We will not handle it but things may be unexpected if the item is actually being deleted from the old material editor
 203                         /*CRY_ASSERT_MESSAGE(0, "Material was deleted by other means while it was being edited, this case is not well handled");
 204                            TryCloseAsset();*/
 205                         break;
 206                 default:
 207                         break;
 208                 }
 209         }
 210         else if (item->GetParent() == m_pMaterial.get())
 211         {
 212                 switch (event)
 213                 {
 214                 case EDB_ITEM_EVENT_CHANGED:
 215                 case EDB_ITEM_EVENT_UPDATE_PROPERTIES:
 216                         signalMaterialPropertiesChanged(item);
 217                         if (GetAssetBeingEdited())
 218                         {
 219                                 GetAssetBeingEdited()->SetModified(true);
 220                         }
 221                         break;
 222                 case EDB_ITEM_EVENT_DELETE: //deleted from DB, what to do ?
 223                         if (item == m_pEditedMaterial)
 224                         {
 225                                 SelectMaterialForEdit(nullptr);
 226                         }
 227                         break;
 228                 default:
 229                         break;
 230                 }
 231         }
 232 }
 233
 234 void CMaterialEditor::OnSubMaterialsChanged(CMaterial::SubMaterialChange change)
 235 {
 236         if (GetAssetBeingEdited())
 237         {
 238                 GetAssetBeingEdited()->SetModified(true);
 239         }
 240
 241         switch (change)
 242         {
 243         case CMaterial::MaterialConverted:
 244                 if (m_pMaterial->IsMultiSubMaterial())
 245                 {
 246                         if (m_pMaterial->GetSubMaterialCount() > 0)
 247                         {
 248                                 SelectMaterialForEdit(m_pMaterial->GetSubMaterial(0));
 249                         }
 250                         else
 251                         {
 252                                 SelectMaterialForEdit(nullptr);
 253                         }
 254                 }
 255                 else
 256                 {
 257                         SelectMaterialForEdit(m_pMaterial);
 258                 }
 259                 break;
 260         case CMaterial::SubMaterialSet:
 261                 //If the material we are currently editing is no longer a child of loaded material, clear it
 262                 if (m_pEditedMaterial && m_pMaterial->IsMultiSubMaterial() && m_pEditedMaterial->GetParent() != m_pMaterial)
 263                 {
 264                         SelectMaterialForEdit(nullptr);
 265                 }
 266                 break;
 267         case CMaterial::SlotCountChanged:
 268                 if (m_pMaterial->IsMultiSubMaterial() && m_pMaterial->GetSubMaterialCount() == 0)
 269                 {
 270                         SelectMaterialForEdit(nullptr);
 271                 }
 272                 break;
 273         default:
 274                 break;
 275         }
 276 }
 277
 278 void CMaterialEditor::CreateDefaultLayout(CDockableContainer* pSender)
 279 {
 280         QWidget* pCenterWidget = pSender->SpawnWidget("Properties");
 281         pSender->SpawnWidget("Preview", pCenterWidget, QToolWindowAreaReference::Right);
 282         QWidget* pMaterialWidget = pSender->SpawnWidget("Material", pCenterWidget, QToolWindowAreaReference::Top);
 283         pSender->SetSplitterSizes(pMaterialWidget, { 1, 4 });
 284 }
 285
 286 void CMaterialEditor::OnLayoutChange(const QVariantMap& state)
 287 {
 288         //Rebroadcast on layout change
 289         //Do not update inspector as the properties pane is unique anyway
 290         if (m_pMaterial)
 291         {
 292                 signalMaterialLoaded(m_pMaterial);
 293                 if (m_pEditedMaterial)
 294                 {
 295                         signalMaterialForEditChanged(m_pEditedMaterial);
 296                         BroadcastPopulateInspector();
 297                 }
 298         }
 299         CAssetEditor::OnLayoutChange(state);
 300 }
 301
 302 bool CMaterialEditor::OnOpenAsset(CAsset* pAsset)
 303 {
 304         using namespace Private_MaterialEditor;
 305
 306         CAbstractMenu* materialMenu = GetMenu(tr("Material"));
 307         CRY_ASSERT(materialMenu);
 308         materialMenu->SetEnabled(!pAsset->IsImmutable());
 309
 310         const auto& filename = pAsset->GetFile(0);
 311         CRY_ASSERT(filename && *filename);
 312
 313         const string materialName = GetIEditor()->GetMaterialManager()->FilenameToMaterial(filename);
 314
 315         CMaterial* pMaterial = CSession::GetSessionMaterial(pAsset);
 316         if (!pMaterial)
 317         {
 318                 pMaterial = static_cast<CMaterial*>(GetIEditor()->GetMaterialManager()->FindItemByName(materialName));
 319         }
 320
 321         if (!pMaterial)
 322         {
 323                 pMaterial = GetIEditor()->GetMaterialManager()->LoadMaterial(materialName, false);
 324         }
 325         else if (!pAsset->IsModified())
 326         {
 327                 pMaterial->Reload(); //Enforce loading from file every time as we cannot assume the file has not changed compared to in-memory material
 328         }
 329
 330         if (!pMaterial)
 331         {
 332                 return false;
 333         }
 334
 335         SetMaterial(pMaterial);
 336
 337         return true;
 338 }
 339
 340 bool CMaterialEditor::OnSaveAsset(CEditableAsset& editAsset)
 341 {
 342         return GetAssetBeingEdited()->GetEditingSession()->OnSaveAsset(editAsset);
 343 }
 344
 345 void CMaterialEditor::OnCloseAsset()
 346 {
 347         SetMaterial(nullptr);
 348 }
 349
 350 void CMaterialEditor::OnDiscardAssetChanges(CEditableAsset& editAsset)
 351 {
 352         CRY_ASSERT(GetAssetBeingEdited());
 353         CRY_ASSERT(GetAssetBeingEdited()->GetEditingSession());
 354
 355         GetAssetBeingEdited()->GetEditingSession()->DiscardChanges(editAsset);
 356 }
 357
 358 std::unique_ptr<IAssetEditingSession> CMaterialEditor::CreateEditingSession()
 359 {
 360         using namespace Private_MaterialEditor;
 361
 362         if (!m_pMaterial)
 363         {
 364                 return nullptr;
 365         }
 366
 367         CSession* pSession = new CSession(m_pMaterial);
 368         return std::unique_ptr<IAssetEditingSession>(pSession);
 369 }
 370
 371 void CMaterialEditor::SelectMaterialForEdit(CMaterial* pMaterial)
 372 {
 373         if (pMaterial != m_pEditedMaterial)
 374         {
 375                 m_pEditedMaterial = pMaterial;
 376
 377                 signalMaterialForEditChanged(pMaterial);
 378
 379                 BroadcastPopulateInspector();
 380         }
 381 }
 382
 383 void CMaterialEditor::BroadcastPopulateInspector()
 384 {
 385         if (m_pEditedMaterial)
 386         {
 387                 m_pMaterialSerializer.reset(new CMaterialSerializer(m_pEditedMaterial, !m_pEditedMaterial->CanModify()));
 388                 string title = m_pMaterial->GetName();
 389                 if (m_pMaterial->IsMultiSubMaterial())
 390                 {
 391                         title += " [";
 392                         title += m_pEditedMaterial->GetName();
 393                         title += "]";
 394                 }
 395
 396                 PopulateInspectorEvent event([this](CInspector& inspector)
 397                 {
 398                   inspector.AddPropertyTree(m_pMaterialSerializer->CreatePropertyTree());
 399                 }, title);
 400                 event.Broadcast(this);
 401         }
 402         else
 403         {
 404                 m_pMaterialSerializer.reset();
 405                 ClearInspectorEvent().Broadcast(this);
 406         }
 407 }
 408
 409 void CMaterialEditor::SetMaterial(CMaterial* pMaterial)
 410 {
 411         if (pMaterial != m_pMaterial)
 412         {
 413                 if (m_pMaterial)
 414                 {
 415                         m_pMaterial->signalSubMaterialsChanged.DisconnectObject(this);
 416                 }
 417
 418                 SelectMaterialForEdit(nullptr);
 419
 420                 m_pMaterial = pMaterial;
 421
 422                 signalMaterialLoaded(m_pMaterial);
 423
 424                 if (m_pMaterial)
 425                 {
 426                         m_pMaterial->signalSubMaterialsChanged.Connect(this, &CMaterialEditor::OnSubMaterialsChanged);
 427
 428                         if (m_pMaterial->IsMultiSubMaterial())
 429                         {
 430                                 if (m_pMaterial->GetSubMaterialCount() > 0)
 431                                         SelectMaterialForEdit(m_pMaterial->GetSubMaterial(0));
 432                                 else
 433                                         SelectMaterialForEdit(nullptr);
 434                         }
 435                         else
 436                                 SelectMaterialForEdit(m_pMaterial);
 437                 }
 438         }
 439 }
 440
 441 void CMaterialEditor::FillMaterialMenu(CAbstractMenu* menu)
 442 {
 443         menu->Clear();
 444
 445         int sec = menu->GetNextEmptySection();
 446
 447         auto action = menu->CreateAction(tr("Convert To Multi-Material"), sec);
 448         action->setEnabled(m_pMaterial && !m_pMaterial->IsMultiSubMaterial());
 449         connect(action, &QAction::triggered, this, &CMaterialEditor::OnConvertToMultiMaterial);
 450
 451         sec = menu->GetNextEmptySection();
 452
 453         action = menu->CreateAction(tr("Convert To Single Material"), sec);
 454         action->setEnabled(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 455         connect(action, &QAction::triggered, this, &CMaterialEditor::OnConvertToSingleMaterial);
 456
 457         action = menu->CreateAction(tr("Add Sub-Material"), sec);
 458         action->setEnabled(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 459         connect(action, &QAction::triggered, this, &CMaterialEditor::OnAddSubMaterial);
 460
 461         action = menu->CreateAction(tr("Set Sub-Material Slot Count..."), sec);
 462         action->setEnabled(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 463         connect(action, &QAction::triggered, this, &CMaterialEditor::OnSetSubMaterialSlotCount);
 464 }
 465
 466 void CMaterialEditor::OnConvertToMultiMaterial()
 467 {
 468         CUndo undo("Convert To Multi-Material");
 469         CRY_ASSERT(m_pMaterial && !m_pMaterial->IsMultiSubMaterial());
 470         m_pMaterial->ConvertToMultiMaterial();
 471 }
 472
 473 void CMaterialEditor::OnConvertToSingleMaterial()
 474 {
 475         CUndo undo("Convert To Single Material");
 476         CRY_ASSERT(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 477         m_pMaterial->ConvertToSingleMaterial();
 478 }
 479
 480 void CMaterialEditor::OnAddSubMaterial()
 481 {
 482         CUndo undo("Add Sub-Material");
 483         CRY_ASSERT(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 484
 485         const auto count = m_pMaterial->GetSubMaterialCount();
 486         m_pMaterial->SetSubMaterialCount(count + 1);
 487         m_pMaterial->ResetSubMaterial(count, false);
 488 }
 489
 490 void CMaterialEditor::OnSetSubMaterialSlotCount()
 491 {
 492         CRY_ASSERT(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 493         QNumericBoxDialog dialog("Set Sub-Material Slot Count", m_pMaterial->GetSubMaterialCount(), this);
 494
 495         dialog.RestrictToInt();
 496         dialog.SetMin(0);
 497
 498         if (dialog.Execute())
 499         {
 500                 CUndo undo("Set Sub-Material Slot Count");
 501                 const int newCount = dialog.GetValue();
 502                 m_pMaterial->SetSubMaterialCount(newCount);
 503
 504                 for (int i = 0; i < newCount; i++)
 505                 {
 506                         m_pMaterial->ResetSubMaterial(i, true);
 507                 }
 508         }
 509 }
 510
 511 void CMaterialEditor::OnPickMaterial()
 512 {
 513         auto pickMaterialTool = new CPickMaterialTool();
 514         pickMaterialTool->SetActiveEditor(this);
 515
 516         GetIEditor()->GetLevelEditorSharedState()->SetEditTool(pickMaterialTool);
 517 }
 518
 519 void CMaterialEditor::OnResetSubMaterial(int slot)
 520 {
 521         CUndo undo("Reset Sub-Material");
 522         CRY_ASSERT(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 523         m_pMaterial->ResetSubMaterial(slot, false);
 524 }
 525
 526 void CMaterialEditor::OnRemoveSubMaterial(int slot)
 527 {
 528         CUndo undo("Remove Sub-Material");
 529         CRY_ASSERT(m_pMaterial && m_pMaterial->IsMultiSubMaterial());
 530         m_pMaterial->SetSubMaterial(slot, nullptr);
 531 }