Code/Sandbox/Plugins/MeshImporter/SceneModel.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2 #include "StdAfx.h"
   3 #include "SceneModel.h"
   4 #include "Scene/SceneElementSourceNode.h"
   5 #include "Scene/SceneElementPhysProxies.h"
   6 #include "Scene/SceneElementProxyGeom.h"
   7 #include "Scene/SceneElementSkin.h"
   8 #include "Scene/SceneElementTypes.h"
   9 #include "Scene/Scene.h"
  10 #include "SceneUserData.h"
  11 #include "DialogMesh/DialogMesh_SceneUserData.h"
  12 #include "FbxMetaData.h"
  13 #include <QVariant>
  14 #include <QPixmap>
  15
  16 #include <CryIcon.h>
  17
  18 #include <EditorStyleHelper.h>
  19
  20 namespace
  21 {
  22
  23 const FbxTool::ENodeExportSetting kDefaultSceneExportSetting = FbxTool::eNodeExportSetting_Include;
  24
  25 CItemModelAttributeEnumFunc s_meshTypeAttribute("Mesh Type", []()
  26 {
  27         QStringList strs;
  28         strs.reserve(MAX_STATOBJ_LODS_NUM + 1);
  29         for (int i = 0; i < MAX_STATOBJ_LODS_NUM; ++i)
  30         {
  31                 strs.push_back(QString("LOD %1").arg(i));
  32         }
  33         strs.push_back(QStringLiteral("Physics Proxy"));
  34         return strs;
  35 });
  36
  37 } // namespace
  38
  39 CSceneModel::CSceneModel()
  40         : CSceneModelCommon()
  41         , m_pExportIcon(new CryIcon())
  42         , m_pSceneUserData(nullptr)
  43 {
  44         QPixmap enabledIcon = QStringLiteral("icons:General/Tick_On.ico");
  45         QPixmap disabledIcon = QStringLiteral("icons:General/Tick_Off.ico");
  46         assert(enabledIcon.width() == enabledIcon.height());
  47         assert(disabledIcon.width() == disabledIcon.height());
  48         assert(enabledIcon.width() == disabledIcon.width());
  49         m_pExportIcon->addPixmap(enabledIcon, CryIcon::Normal, CryIcon::On);
  50         m_pExportIcon->addPixmap(disabledIcon, CryIcon::Normal, CryIcon::Off);
  51         m_iconDimension = enabledIcon.height();
  52 }
  53
  54 CSceneModel::~CSceneModel()
  55 {
  56         delete m_pExportIcon;
  57 }
  58
  59 static bool IsNotExcluded(CSceneElementSourceNode* pSceneElement)
  60 {
  61         const FbxTool::SNode* pNode = pSceneElement->GetNode();
  62         const FbxTool::ENodeExportSetting exportSetting = pNode->pScene->GetNodeExportSetting(pNode);
  63         return exportSetting != FbxTool::eNodeExportSetting_Exclude;
  64 }
  65
  66 const FbxMetaData::SSceneUserSettings& CSceneModel::GetSceneUserSettings() const
  67 {
  68         return m_userSettings;
  69 }
  70
  71 static bool GetLodIndex(const char* const szName, const char* szPrefix, int& lod)
  72 {
  73         const size_t lodNamePrefixLength = strlen(szPrefix);
  74
  75         if (strnicmp(szName, szPrefix, lodNamePrefixLength))
  76         {
  77                 return false;
  78         }
  79
  80         const int value = atoi(szName + lodNamePrefixLength);
  81         if (value >= 1 && value < MAX_STATOBJ_LODS_NUM)
  82         {
  83                 lod = value;
  84                 return true;
  85         }
  86
  87         return false;
  88 }
  89
  90 static bool IsSceneRoot(CSceneElementSourceNode* pSceneElement)
  91 {
  92         return pSceneElement->GetNode() && !pSceneElement->GetNode()->pParent;
  93 }
  94
  95 static void AutoAssignLods(CScene& scene, FbxTool::CScene* pFbxScene)
  96 {
  97         for (int i = 0; i < scene.GetElementCount(); ++i)
  98         {
  99                 if (scene.GetElementByIndex(i)->GetType() != ESceneElementType::SourceNode)
 100                 {
 101                         continue;
 102                 }
 103
 104                 CSceneElementSourceNode* const pElement = (CSceneElementSourceNode*)scene.GetElementByIndex(i);
 105
 106                 if (!pElement->IsLeaf())
 107                 {
 108                         continue;
 109                 }
 110
 111                 int lod = -1;
 112
 113                 // Try to match 3ds Max convention:
 114                 // $lod{N}[name] is N-th LOD of parent.
 115                 if (GetLodIndex(pElement->GetName().c_str(), "$lod", lod))
 116                 {
 117                         pFbxScene->SetNodeLod(pElement->GetNode(), lod);
 118                 }
 119
 120                 // Try to match Maya convention:
 121                 // single child of node with name _lod{N}_name_group is N-th LOD of parent.
 122                 if (pElement->GetParent() && GetLodIndex(pElement->GetParent()->GetName().c_str(), "_lod", lod))
 123                 {
 124                         pFbxScene->SetNodeLod(pElement->GetNode(), lod);
 125                 }
 126         }
 127 }
 128
 129 void CSceneModel::SetScene(FbxTool::CScene* pScene, const FbxMetaData::SSceneUserSettings& userSettings)
 130 {
 131         CSceneModelCommon::SetScene(pScene);
 132
 133         m_userSettings = userSettings;
 134
 135         for (int i = 0; i < GetElementCount(); ++i)
 136         {
 137                 if (GetElementById(i)->GetType() != ESceneElementType::SourceNode)
 138                 {
 139                         continue;
 140                 }
 141
 142                 CSceneElementSourceNode* const pElement = (CSceneElementSourceNode*)GetElementById(i);
 143                 const FbxTool::SNode* const pNode = pElement->GetNode();
 144
 145                 pScene->SetNodeExportSetting(pNode, GetDefaultNodeExportSetting(pNode));
 146         }
 147
 148         AutoAssignLods(*GetModelScene(), GetScene());
 149 }
 150
 151 void CSceneModel::SetSceneUserData(DialogMesh::CSceneUserData* pSceneUserData)
 152 {
 153         m_pSceneUserData = pSceneUserData;
 154 }
 155
 156 void CSceneModel::SetExportSetting(const QModelIndex& index, FbxTool::ENodeExportSetting value)
 157 {
 158         setData(index, (int)value, eRoleType_Export);
 159 }
 160
 161 static void ResetExportSettingsInSubtree(FbxTool::CScene* pScene, const FbxTool::SNode* pFbxNode)
 162 {
 163         pScene->SetNodeExportSetting(pFbxNode, FbxTool::eNodeExportSetting_Include);
 164
 165         for (int i = 0; i < pFbxNode->numChildren; ++i)
 166         {
 167                 ResetExportSettingsInSubtree(pScene, pFbxNode->ppChildren[i]);
 168         }
 169 }
 170
 171 void CSceneModel::ResetExportSettingsInSubtree(const QModelIndex& index)
 172 {
 173         CSceneElementCommon* const pSelf = GetSceneElementFromModelIndex(index);
 174         if (!pSelf || pSelf->GetType() != ESceneElementType::SourceNode)
 175         {
 176                 return;
 177         }
 178
 179         CSceneElementSourceNode* const pSourceNodeElement = (CSceneElementSourceNode*)pSelf;
 180         CRY_ASSERT(IsSceneRoot(pSourceNodeElement));
 181
 182         // Reset settings of this LOD's FBX root element.
 183         ::ResetExportSettingsInSubtree(GetScene(), pSourceNodeElement->GetNode());
 184
 185         Reset();
 186 }
 187
 188 void CSceneModel::OnDataSerialized(CSceneElementCommon* pElement, bool bChanged)
 189 {
 190         if (bChanged)
 191         {
 192                 QModelIndex index = GetModelIndexFromSceneElement(pElement);
 193                 assert(index.isValid());
 194                 const QModelIndex firstChanged = sibling(index.row(), 0, index);
 195                 const QModelIndex lastChanged = sibling(index.row(), columnCount(index) - 1, index);
 196                 dataChanged(firstChanged, lastChanged);
 197         }
 198 }
 199
 200 int CSceneModel::columnCount(const QModelIndex& index) const
 201 {
 202         return eColumnType_COUNT;
 203 }
 204
 205 static FbxTool::ENodeExportSetting EvaluateExportSetting(const FbxTool::CScene* pFbxScene, const FbxTool::SNode* pFbxNode)
 206 {
 207         return pFbxScene->IsNodeIncluded(pFbxNode) ? FbxTool::eNodeExportSetting_Include : FbxTool::eNodeExportSetting_Exclude;
 208 }
 209
 210 void CSceneModel::GetCheckStateRole(CSceneElementSourceNode* pSelf, EState& state, bool& bPartial) const
 211 {
 212         const CSceneElementSourceNode* pParent = nullptr;
 213         if (pSelf->GetParent() && pSelf->GetParent()->GetType() == ESceneElementType::SourceNode)
 214         {
 215                 pParent = (CSceneElementSourceNode*)pSelf->GetParent();
 216         }
 217
 218         if (EvaluateExportSetting(GetScene(), pSelf->GetNode()) == FbxTool::eNodeExportSetting_Include)
 219         {
 220                 state = eState_Enabled_Included;
 221         }
 222         else if (pParent && EvaluateExportSetting(GetScene(), pParent->GetNode()) == FbxTool::eNodeExportSetting_Include)
 223         {
 224                 state = eState_Enabled_Excluded;
 225         }
 226         else if (GetScene()->GetNodeExportSetting(pSelf->GetNode()) == FbxTool::eNodeExportSetting_Include)
 227         {
 228                 state = eState_Disabled_Included;
 229         }
 230         else
 231         {
 232                 state = eState_Disabled_Excluded;
 233         }
 234
 235         bPartial = false;
 236
 237         // TODO: Compute this for all elements in a single pass.
 238         std::vector<const CSceneElementCommon*> elementStack;
 239         elementStack.push_back(pSelf);
 240         while (!elementStack.empty() && !bPartial)
 241         {
 242                 const CSceneElementCommon* pElement = elementStack.back();
 243                 elementStack.pop_back();
 244
 245                 if (pElement->GetType() == ESceneElementType::SourceNode)
 246                 {
 247                         const FbxTool::SNode* const pNode = ((CSceneElementSourceNode*)pElement)->GetNode();
 248                         if (GetScene()->GetNodeExportSetting(pNode) == FbxTool::eNodeExportSetting_Exclude)
 249                         {
 250                                 bPartial = true;
 251                         }
 252                 }
 253
 254                 for (int i = 0; i < pElement->GetNumChildren(); ++i)
 255                 {
 256                         elementStack.push_back(pElement->GetChild(i));
 257                 }
 258         }
 259
 260 }
 261
 262 bool CanBeLod(const FbxTool::SNode* pNode)
 263 {
 264         return
 265                 pNode->pParent &&
 266                 !pNode->numChildren &&
 267                 EvaluateExportSetting(pNode->pScene, pNode) == FbxTool::eNodeExportSetting_Include &&
 268                 pNode->numMeshes;
 269 }
 270
 271 template<typename T>
 272 QVariant CreateSerializationVariant(const T& t)
 273 {
 274         std::unique_ptr<Serialization::SStruct> sstruct(new Serialization::SStruct(t));
 275         return QVariant::fromValue((void*)sstruct.release());
 276 }
 277
 278 QVariant CSceneModel::GetSourceNodeData(CSceneElementSourceNode* pSelf, const QModelIndex& index, int role) const
 279 {
 280         if (role == eItemDataRole_YasliSStruct)
 281         {
 282                 return CreateSerializationVariant(*pSelf);
 283         }
 284
 285         const FbxTool::SNode* const pNode = pSelf->GetNode();
 286
 287         EState state;
 288         bool bPartial;
 289         GetCheckStateRole(pSelf, state, bPartial);
 290
 291         switch (index.column())
 292         {
 293         case eColumnType_Name:
 294                 if (role == Qt::DisplayRole)
 295                 {
 296                         return QtUtil::ToQString(pSelf->GetName());
 297                 }
 298                 else if (role == Qt::CheckStateRole)
 299                 {
 300                         if (m_pSceneUserData->GetSelectedSkin())
 301                         {
 302                                 return QVariant();
 303                         }
 304
 305                         if (state == eState_Enabled_Included || state == eState_Disabled_Included)
 306                         {
 307                                 return bPartial ? Qt::PartiallyChecked : Qt::Checked;
 308                         }
 309                         else if (state == eState_Enabled_Excluded || state == eState_Disabled_Excluded)
 310                         {
 311                                 return Qt::Unchecked;
 312                         }
 313                 }
 314                 else if (role == Qt::ForegroundRole)
 315                 {
 316                         if (state == eState_Disabled_Included || state == eState_Disabled_Excluded)
 317                         {
 318                                 return QBrush(GetStyleHelper()->disabledTextColor());
 319                         }
 320                         else
 321                         {
 322                                 return QBrush(GetStyleHelper()->textColor());
 323                         }
 324                 }
 325                 break;
 326         case eColumnType_Type:
 327                 if (role == Qt::EditRole && CanBeLod(pNode))
 328                 {
 329                         return GetScene()->IsProxy(pNode) ? MAX_STATOBJ_LODS_NUM : GetScene()->GetNodeLod(pNode);
 330                 }
 331                 else if (role == Qt::DisplayRole && CanBeLod(pNode))
 332                 {
 333                         return QString("LOD %1").arg(GetScene()->IsProxy(pNode) ? MAX_STATOBJ_LODS_NUM : GetScene()->GetNodeLod(pNode));
 334                 }
 335                 else if (role == Qt::DisplayRole && !IsSceneRoot(pSelf) && !CanBeLod(pNode))
 336                 {
 337                         return "LOD 0";  // Just display lod, non-editable.
 338                 }
 339                 break;
 340         case eColumnType_SourceNodeAttribute:
 341                 if (role == Qt::DisplayRole && !pNode->namedAttributes.empty())
 342                 {
 343                         return QtUtil::ToQString(pNode->namedAttributes[0]);
 344                 }
 345                 break;
 346         default:
 347                 assert(false);
 348                 break;
 349         }
 350         if (role == Qt::ToolTipRole)
 351         {
 352                 return GetToolTipForColumn(index.column());
 353         }
 354
 355         return CSceneModelCommon::data(index, role);
 356 }
 357
 358 bool IsSkinElementSelected(DialogMesh::CSceneUserData* pSceneUserData, CSceneElementSkin* pSkinElement)
 359 {
 360         CSceneElementSourceNode* const pSourceNodeElement = (CSceneElementSourceNode*)pSkinElement->GetParent();
 361         return pSceneUserData->GetSelectedSkin() && pSourceNodeElement->GetNode() == pSceneUserData->GetSelectedSkin()->pNode;
 362 }
 363
 364 QVariant CSceneModel::GetSkinData(CSceneElementSkin* pSelf, const QModelIndex& index, int role) const
 365 {
 366         switch (index.column())
 367         {
 368         case eColumnType_Name:
 369                 if (role == Qt::DisplayRole)
 370                 {
 371                         return QtUtil::ToQString(pSelf->GetName());
 372                 }
 373                 else if (role == Qt::CheckStateRole)
 374                 {
 375                         if (IsSkinElementSelected(m_pSceneUserData, pSelf))
 376                         {
 377                                 return Qt::Checked;
 378                         }
 379                         else
 380                         {
 381                                 return Qt::Unchecked;
 382                         }
 383                 }
 384                 break;
 385         case eColumnType_Type:
 386                 if (role == Qt::DisplayRole)
 387                 {
 388                         return "Skin";
 389                 }
 390                 break;
 391         default:
 392                 break;
 393         }
 394         if (role == Qt::ToolTipRole)
 395         {
 396                 return GetToolTipForColumn(index.column());
 397         }
 398
 399         return CSceneModelCommon::data(index, role);
 400 }
 401
 402 QVariant CSceneModel::data(const QModelIndex& index, int role) const
 403 {
 404         if (!index.isValid())
 405         {
 406                 return QVariant();
 407         }
 408
 409         CSceneElementCommon* const pSelf = GetSceneElementFromModelIndex(index);
 410         assert(pSelf);
 411
 412         if (pSelf->GetType() == ESceneElementType::SourceNode)
 413         {
 414                 return GetSourceNodeData((CSceneElementSourceNode*)pSelf, index, role);
 415         }
 416         else if(pSelf->GetType() == ESceneElementType::Skin)
 417         {
 418                 return GetSkinData((CSceneElementSkin*)pSelf, index, role);
 419         }
 420         else if (pSelf->GetType() == ESceneElementType::ProxyGeom || pSelf->GetType() == ESceneElementType::PhysProxy)
 421         {
 422                 if (role == eItemDataRole_YasliSStruct)
 423                 {
 424                         if (pSelf->GetType() == ESceneElementType::PhysProxy)
 425                         {
 426                                 return CreateSerializationVariant(*(CSceneElementPhysProxies*)pSelf);
 427                         }
 428                         else
 429                         {
 430                                 return CreateSerializationVariant(*(CSceneElementProxyGeom*)pSelf);
 431                         }
 432                 }
 433                 else if (index.column() == eColumnType_Name && role == Qt::DisplayRole)
 434                 {
 435                         return QtUtil::ToQString(pSelf->GetName());
 436                 }
 437         }
 438         return CSceneModelCommon::data(index, role);
 439 }
 440
 441 bool CSceneModel::SetDataSourceNodeElement(const QModelIndex& index, const QVariant& value, int role)
 442 {
 443         CSceneElementSourceNode* const pSourceNodeElement = (CSceneElementSourceNode*)GetSceneElementFromModelIndex(index);
 444
 445         const FbxTool::SNode* const pNode = pSourceNodeElement->GetNode();
 446
 447         if (role == Qt::CheckStateRole)
 448         {
 449                 const auto checkState = (Qt::CheckState)value.toUInt();
 450
 451                 if (GetScene()->GetNodeExportSetting(pNode) == FbxTool::eNodeExportSetting_Include && checkState == Qt::Checked)
 452                 {
 453                         GetScene()->SetNodeExportSetting(pNode, FbxTool::eNodeExportSetting_Exclude);
 454                 }
 455                 else
 456                 {
 457                         const auto exportSetting =
 458                           checkState == Qt::Checked
 459                           ? FbxTool::eNodeExportSetting_Include
 460                           : FbxTool::eNodeExportSetting_Exclude;
 461                         GetScene()->SetNodeExportSetting(pNode, exportSetting);
 462                 }
 463
 464                 Reset();
 465
 466                 return true;
 467         }
 468         if (role == eRoleType_Export)
 469         {
 470                 GetScene()->SetNodeExportSetting(pNode, static_cast<FbxTool::ENodeExportSetting>(value.value<int>()));
 471
 472                 Reset();
 473
 474                 return true;
 475         }
 476         else if (index.column() == eColumnType_Type && role == Qt::EditRole)
 477         {
 478                 const int i = value.toInt();
 479                 if (i < MAX_STATOBJ_LODS_NUM)
 480                 {
 481                         GetScene()->SetNodeLod(pNode, i);
 482                         GetScene()->SetProxy(pNode, false);
 483                 }
 484                 else
 485                 {
 486                         GetScene()->SetNodeLod(pNode, 0);
 487                         GetScene()->SetProxy(pNode, true);
 488                 }
 489
 490                 const QModelIndex firstChanged = sibling(index.row(), 0, index);
 491                 const QModelIndex lastChanged = sibling(index.row(), eColumnType_COUNT - 1, index);
 492                 dataChanged(firstChanged, lastChanged);
 493                 return true;
 494         }
 495
 496         return false;
 497 }
 498
 499 bool CSceneModel::SetDataSkinElement(const QModelIndex& index, const QVariant& value, int role)
 500 {
 501         CSceneElementSkin* const pSkinElement = (CSceneElementSkin*)GetSceneElementFromModelIndex(index);
 502
 503         CRY_ASSERT(pSkinElement->GetParent() && pSkinElement->GetParent()->GetType() == ESceneElementType::SourceNode);
 504         CSceneElementSourceNode* const pSourceNodeElement = (CSceneElementSourceNode*)pSkinElement->GetParent();
 505
 506         const FbxTool::SNode* const pNode = pSourceNodeElement->GetNode();
 507
 508         if (role == Qt::CheckStateRole)
 509         {
 510                 const auto checkState = (Qt::CheckState)value.toUInt();
 511
 512                 if (checkState == Qt::Checked)
 513                 {
 514                         m_pSceneUserData->SelectAnySkin(pNode);
 515                 }
 516                 else
 517                 {
 518                         m_pSceneUserData->DeselectSkin();
 519                 }
 520
 521                 Reset();
 522
 523                 return true;
 524         }
 525
 526         return false;
 527 }
 528
 529 bool CSceneModel::setData(const QModelIndex& index, const QVariant& value, int role)
 530 {
 531         if (!index.isValid())
 532         {
 533                 return false;
 534         }
 535
 536         CSceneElementCommon* const pElement = GetSceneElementFromModelIndex(index);
 537         CRY_ASSERT(pElement);
 538
 539         if (pElement->GetType() == ESceneElementType::SourceNode)
 540         {
 541                 return SetDataSourceNodeElement(index, value, role);
 542         }
 543         else if (pElement->GetType() == ESceneElementType::Skin)
 544         {
 545                 return SetDataSkinElement(index, value, role);
 546         }
 547
 548         return false;
 549 }
 550
 551 CItemModelAttribute* CSceneModel::GetColumnAttribute(int col) const
 552 {
 553         switch(col)
 554         {
 555         case eColumnType_Name:
 556                 return &Attributes::s_nameAttribute;
 557         case eColumnType_Type:
 558                 return &s_meshTypeAttribute;
 559         case eColumnType_SourceNodeAttribute:
 560                 return GetSourceNodeAttributeAttribute();
 561         default:
 562                 return nullptr;
 563         };
 564 }
 565
 566 QVariant CSceneModel::headerData(int column, Qt::Orientation orientation, int role) const
 567 {
 568         switch (column)
 569         {
 570         case eColumnType_Name:
 571                 if (role == Qt::DisplayRole)
 572                 {
 573                         return tr("Name");
 574                 }
 575                 break;
 576         case eColumnType_Type:
 577                 if (role == Qt::DisplayRole)
 578                 {
 579                         return tr("Type");
 580                 }
 581                 break;
 582         case eColumnType_SourceNodeAttribute:
 583                 if (role == Qt::DisplayRole)
 584                 {
 585                         return tr("Attribute");
 586                 }
 587         default:
 588                 break;
 589         }
 590
 591         if (role == Qt::ToolTipRole)
 592         {
 593                 return GetToolTipForColumn(column);
 594         }
 595
 596         // Attributes.
 597         if (role == Attributes::s_getAttributeRole)
 598         {
 599                 CItemModelAttribute* const pAttribute = GetColumnAttribute(column);
 600                 if (pAttribute)
 601                 {
 602                         return QVariant::fromValue(pAttribute);
 603                 }
 604         }
 605
 606         return QVariant();
 607 }
 608
 609 Qt::ItemFlags CSceneModel::flags(const QModelIndex& modelIndex) const
 610 {
 611         if (!modelIndex.isValid())
 612         {
 613                 return CSceneModelCommon::flags(modelIndex);
 614         }
 615
 616         const CSceneElementCommon* const pSelf = GetSceneElementFromModelIndex(modelIndex);
 617         CRY_ASSERT(pSelf);
 618
 619         bool bCanBeLod = false;
 620
 621         if (pSelf->GetType() == ESceneElementType::SourceNode)
 622         {
 623                 bCanBeLod = CanBeLod(((CSceneElementSourceNode*)pSelf)->GetNode());
 624         }
 625
 626         if (modelIndex.column() == eColumnType_Type && bCanBeLod)
 627         {
 628                 return Qt::ItemIsEditable | QAbstractItemModel::flags(modelIndex);
 629         }
 630         else if (modelIndex.column() == eColumnType_Name)
 631         {
 632                 return Qt::ItemIsUserCheckable | QAbstractItemModel::flags(modelIndex);
 633         }
 634         else
 635         {
 636                 return QAbstractItemModel::flags(modelIndex);
 637         }
 638 }
 639
 640 QVariant CSceneModel::GetToolTipForColumn(int column)
 641 {
 642         switch (column)
 643         {
 644         case eColumnType_Name:
 645                 return tr("Name of the node in the scene");
 646         case eColumnType_Type:
 647                 return tr("Type of this node");
 648         case eColumnType_SourceNodeAttribute:
 649                 return tr("Attributes of this node");
 650         default:
 651                 assert(false);
 652                 break;
 653         }
 654         return QVariant();
 655 }