Code/Sandbox/Plugins/EditorParticle/Models/ParticleGraphItems.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "ParticleGraphItems.h"
   5
   6 #include "../Undo.h"
   7
   8 #include "Widgets/FeatureGridNodeContentWidget.h"
   9 #include "Widgets/NodeIcons.h"
  10
  11 #include "ParticleGraphModel.h"
  12
  13 #include "QtUtil.h"
  14
  15 #include <NodeGraph/NodeWidget.h>
  16 #include <NodeGraph/PinWidget.h>
  17 #include <NodeGraph/ConnectionWidget.h>
  18 #include <NodeGraph/NodeGraphViewStyle.h>
  19
  20 #include <QVariant>
  21
  22 namespace CryParticleEditor {
  23
  24 CNodeItem::CNodeItem(pfx2::IParticleComponent& component, CryGraphEditor::CNodeGraphViewModel& viewModel)
  25         : CAbstractNodeItem(*(m_pData = new CryGraphEditor::CNodeEditorData()), viewModel)
  26         , m_component(component)
  27 {
  28         SetAcceptsDeactivation(true);
  29         SetAcceptsRenaming(true);
  30
  31         m_name = component.GetName();
  32         m_data.SetPos(Vec2(component.GetNodePosition().x, component.GetNodePosition().y));
  33
  34         uint32 featureCount = m_component.GetNumFeatures();
  35         m_pins.reserve(featureCount + 1);
  36
  37         m_pins.push_back(new CParentPinItem(*this));
  38         m_pins.push_back(new CChildPinItem(*this));
  39
  40         for (uint32 i = 0; i < featureCount; ++i)
  41         {
  42                 pfx2::IParticleFeature* pFeature = m_component.GetFeature(i);
  43                 if (pFeature)
  44                 {
  45                         CFeatureItem* pFeatureItem = new CFeatureItem(*pFeature, *this, viewModel);
  46                         m_features.push_back(pFeatureItem);
  47                         if (pFeatureItem->HasComponentConnector())
  48                         {
  49                                 m_pins.push_back(pFeatureItem->GetPinItem());
  50                         }
  51                 }
  52         }
  53 }
  54
  55 CNodeItem::~CNodeItem()
  56 {
  57         for (CryGraphEditor::CAbstractPinItem* pItem : m_pins)
  58         {
  59                 CBasePinItem* pPintItem = static_cast<CBasePinItem*>(pItem);
  60                 if (pPintItem->GetPinType() == EPinType::Parent || pPintItem->GetPinType() == EPinType::Child)
  61                         delete pPintItem;
  62         }
  63
  64         for (CFeatureItem* pItem : m_features)
  65         {
  66                 delete pItem;
  67         }
  68
  69         delete m_pData;
  70 }
  71
  72 void CNodeItem::SetPosition(QPointF position)
  73 {
  74         m_component.SetNodePosition(Vec2(position.x(), position.y()));
  75         CAbstractNodeItem::SetPosition(position);
  76         if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
  77         {
  78                 CryGraphEditor::CUndoNodeMove* pUndoObject = new CryGraphEditor::CUndoNodeMove(*this);
  79                 CUndo::Record(pUndoObject);
  80         }
  81 }
  82
  83 CryGraphEditor::CNodeWidget* CNodeItem::CreateWidget(CryGraphEditor::CNodeGraphView& view)
  84 {
  85         CryGraphEditor::CNodeWidget* pNode = new CryGraphEditor::CNodeWidget(*this, view);
  86         pNode->SetHeaderNameWidth(120);
  87         CFeatureGridNodeContentWidget* pContent = new CFeatureGridNodeContentWidget(*pNode, static_cast<CParentPinItem&>(*m_pins[0]), static_cast<CChildPinItem&>(*m_pins[1]), view);
  88
  89         pNode->AddHeaderIcon(new CEmitterActiveIcon(*pNode), CryGraphEditor::CHeaderWidget::EIconSlot::Right);
  90         pNode->AddHeaderIcon(new CEmitterVisibleIcon(*pNode), CryGraphEditor::CHeaderWidget::EIconSlot::Right);
  91         pNode->AddHeaderIcon(new CSoloEmitterModeIcon(*pNode), CryGraphEditor::CHeaderWidget::EIconSlot::Right);
  92
  93         pNode->SetContentWidget(pContent);
  94
  95         return pNode;
  96 }
  97
  98 QVariant CNodeItem::GetId() const
  99 {
 100         return QVariant::fromValue(QString(m_component.GetName()));
 101 }
 102
 103 bool CNodeItem::HasId(QVariant id) const
 104 {
 105         QString nodeName = m_component.GetName();
 106         return (nodeName == id.value<QString>());
 107 }
 108
 109 QVariant CNodeItem::GetTypeId() const
 110 {
 111         // Note: Nodes in particle system don't have a type yet.
 112         return QVariant::fromValue(QString());
 113 }
 114
 115 QString CNodeItem::GetName() const
 116 {
 117         return QString(m_component.GetName());
 118 }
 119
 120 void CNodeItem::SetName(const QString& name)
 121 {
 122         const string newName = QtUtil::ToString(name);
 123         const string oldName = m_component.GetName();
 124         if (oldName != newName)
 125         {
 126                 m_component.SetName(newName.c_str());
 127                 CAbstractNodeItem::SetName(GetName());
 128                 OnChanged();
 129
 130                 // TODO: Move this into an CAbstractNodeItem method.
 131                 if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 132                 {
 133                         CUndo::Record(new CryGraphEditor::CUndoNodeNameChange(*this, oldName.c_str()));
 134                 }
 135                 // ~TODO
 136         }
 137 }
 138
 139 bool CNodeItem::IsDeactivated() const
 140 {
 141         return !m_component.IsEnabled();
 142 }
 143
 144 void CNodeItem::SetDeactivated(bool isDeactivated)
 145 {
 146         if (IsDeactivated() != isDeactivated)
 147         {
 148                 m_component.SetEnabled(!isDeactivated);
 149                 SignalDeactivatedChanged(isDeactivated);
 150                 OnChanged();
 151         }
 152 }
 153
 154 void CNodeItem::Serialize(Serialization::IArchive& archive)
 155 {
 156         const string oldName = m_component.GetName();
 157
 158         m_component.Serialize(archive);
 159
 160         // Note: Update everything.
 161         const uint32 numFeatures = m_component.GetNumFeatures();
 162         FeatureItemArray features;
 163         features.reserve(numFeatures);
 164         CryGraphEditor::PinItemArray pins;
 165         pins.push_back(m_pins[0]);
 166         pins.push_back(m_pins[1]);
 167
 168         size_t movedFeatures = 0;
 169
 170         for (uint32 i = 0; i < numFeatures; ++i)
 171         {
 172                 pfx2::IParticleFeature* pFeatureInterface = m_component.GetFeature(i);
 173                 auto predicate = [pFeatureInterface](CFeatureItem* pFeatureItem) -> bool
 174                 {
 175                         return (pFeatureItem && pFeatureInterface == &pFeatureItem->GetFeatureInterface());
 176                 };
 177
 178                 auto result = std::find_if(m_features.begin(), m_features.end(), predicate);
 179                 if (result == m_features.end())
 180                 {
 181                         CFeatureItem* pFeatureItem = new CFeatureItem(*pFeatureInterface, *this, GetViewModel());
 182                         features.push_back(pFeatureItem);
 183                         if (pFeatureItem->HasComponentConnector())
 184                         {
 185                                 pins.push_back(pFeatureItem->GetPinItem());
 186                         }
 187
 188                         SignalFeatureAdded(*pFeatureItem);
 189                 }
 190                 else
 191                 {
 192                         CFeatureItem* pFeatureItem = *result;
 193                         features.push_back(pFeatureItem);
 194                         if (pFeatureItem->HasComponentConnector())
 195                         {
 196                                 pins.push_back(pFeatureItem->GetPinItem());
 197                         }
 198
 199                         pFeatureItem->SignalInvalidated();
 200                         *result = nullptr;
 201                         ++movedFeatures;
 202                 }
 203         }
 204
 205         for (size_t i = 0; i < m_features.size(); ++i)
 206         {
 207                 if (m_features[i] != nullptr)
 208                         RemoveFeature(i);
 209         }
 210
 211         CRY_ASSERT(m_features.size() == movedFeatures);
 212
 213         m_features.swap(features);
 214         m_pins.swap(pins);
 215
 216         CRY_ASSERT(m_features.size() == numFeatures);
 217
 218         SignalInvalidated();
 219 }
 220
 221 CParentPinItem* CNodeItem::GetParentPinItem()
 222 {
 223         return static_cast<CParentPinItem*>(m_pins[0]);
 224 }
 225
 226 CChildPinItem* CNodeItem::GetChildPinItem()
 227 {
 228         return static_cast<CChildPinItem*>(m_pins[1]);
 229 }
 230
 231 uint32 CNodeItem::GetEffectIndex() const
 232 {
 233         CParticleGraphModel& model = static_cast<CParticleGraphModel&>(GetViewModel());
 234         const pfx2::IParticleEffect& effect = model.GetEffectInterface();
 235
 236         const uint32 numNodes = effect.GetNumComponents();
 237         for (uint32 i = 0; i < numNodes; ++i)
 238         {
 239                 if (effect.GetComponent(i) == &m_component)
 240                         return i;
 241         }
 242
 243         return ~0;
 244 }
 245
 246 CFeatureItem* CNodeItem::AddFeature(uint32 index, const pfx2::SParticleFeatureParams& featureParams)
 247 {
 248         m_component.AddFeature(index, featureParams);
 249
 250         pfx2::IParticleFeature* pFeature = m_component.GetFeature(index);
 251         if (pFeature)
 252         {
 253                 CFeatureItem* pFeatureItem = new CFeatureItem(*pFeature, *this, GetViewModel());
 254                 m_features.insert(m_features.begin() + index, pFeatureItem);
 255                 if (pFeatureItem->HasComponentConnector())
 256                 {
 257                         m_pins.push_back(pFeatureItem->GetPinItem());
 258                 }
 259                 SignalFeatureAdded(*pFeatureItem);
 260                 OnChanged();
 261
 262                 if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 263                 {
 264                         CUndo::Record(new CUndoFeatureCreate(*pFeatureItem));
 265                 }
 266
 267                 return pFeatureItem;
 268         }
 269         return nullptr;
 270 }
 271
 272 void CNodeItem::RemoveFeature(uint32 index)
 273 {
 274         if (m_features.size() > index)
 275         {
 276                 CFeatureItem* pFeatureItem = m_features.at(index);
 277
 278                 GetViewModel().SignalRemoveCustomItem(*pFeatureItem);
 279
 280                 m_features.erase(m_features.begin() + index);
 281
 282                 if (CFeaturePinItem* pFeaturePinItem = pFeatureItem->GetPinItem())
 283                 {
 284                         if (pFeaturePinItem->IsConnected())
 285                         {
 286                                 CParticleGraphModel& model = static_cast<CParticleGraphModel&>(GetViewModel());
 287                                 for (CryGraphEditor::CAbstractConnectionItem* pConnectionItem : pFeaturePinItem->GetConnectionItems())
 288                                 {
 289                                         model.RemoveConnection(*pConnectionItem);
 290                                 }
 291                         }
 292                         auto result = std::find(m_pins.begin(), m_pins.end(), pFeatureItem->GetPinItem());
 293                         CRY_ASSERT(result != m_pins.end());
 294                         m_pins.erase(result);
 295                 }
 296
 297                 if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 298                         CUndo::Record(new CUndoFeatureRemove(*pFeatureItem));
 299
 300                 delete pFeatureItem;
 301                 SignalFeatureRemoved(*pFeatureItem);
 302         }
 303
 304         if (index < m_component.GetNumFeatures())
 305                 m_component.RemoveFeature(index);
 306         OnChanged();
 307 }
 308
 309 bool CNodeItem::MoveFeatureAtIndex(uint32 featureIndex, uint32 destIndex)
 310 {
 311         const uint32 maxIndex = m_features.size() - 1;
 312         destIndex = std::min(destIndex, maxIndex);
 313         if (featureIndex != destIndex)
 314         {
 315                 const size_t numFeatures = m_features.size();
 316                 std::vector<uint32> ids;
 317                 ids.reserve(m_features.size());
 318
 319                 for (size_t i = 0; i < numFeatures; ++i)
 320                         ids.push_back(i);
 321
 322                 CFeatureItem* pFeatureItem = m_features[featureIndex];
 323
 324                 ids.erase(ids.begin() + featureIndex);
 325                 ids.insert(ids.begin() + destIndex, featureIndex);
 326
 327                 m_component.SwapFeatures(&ids[0], ids.size());
 328
 329                 m_features.erase(m_features.begin() + featureIndex);
 330                 m_features.insert(m_features.begin() + destIndex, pFeatureItem);
 331
 332                 if (m_component.GetFeature(destIndex) == &pFeatureItem->GetFeatureInterface())
 333                 {
 334                         SignalFeatureMoved(*pFeatureItem);
 335                         OnChanged();
 336                         if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 337                         {
 338                                 CUndo::Record(new CUndoFeatureMove(*pFeatureItem, featureIndex));
 339                                 return true;
 340                         }
 341                 }
 342         }
 343         return false;
 344 }
 345
 346 void CNodeItem::SetVisible(bool isVisible)
 347 {
 348         if (isVisible != m_component.IsVisible())
 349         {
 350                 m_component.SetVisible(isVisible);
 351                 SignalVisibleChanged(isVisible);
 352                 OnChanged();
 353         }
 354 }
 355
 356 bool CNodeItem::IsVisible()
 357 {
 358         return m_component.IsVisible();
 359 }
 360
 361 void CNodeItem::OnChanged()
 362 {
 363         static_cast<CParticleGraphModel*>(&GetViewModel())->OnNodeItemChanged(this);
 364 }
 365
 366 CFeaturePinItem::CFeaturePinItem(CFeatureItem& feature)
 367         : CBasePinItem(feature.GetNodeItem())
 368         , m_featureItem(feature)
 369 {
 370 }
 371
 372 QString CFeaturePinItem::GetName() const
 373 {
 374         return m_featureItem.GetName();
 375 }
 376
 377 QVariant CFeaturePinItem::GetId() const
 378 {
 379         return QVariant::fromValue(m_featureItem.GetName());
 380 }
 381
 382 bool CFeaturePinItem::HasId(QVariant id) const
 383 {
 384         return (m_featureItem.GetName() == id.value<QString>());
 385 }
 386
 387 bool CFeaturePinItem::CanConnect(const CryGraphEditor::CAbstractPinItem* pOtherPin) const
 388 {
 389         if (pOtherPin)
 390                 return pOtherPin->IsInputPin() && !pOtherPin->IsConnected();
 391
 392         return true;
 393 }
 394
 395 bool CParentPinItem::CanConnect(const CryGraphEditor::CAbstractPinItem* pOtherPin) const
 396 {
 397         if (pOtherPin && pOtherPin->IsOutputPin() && !IsConnected())
 398         {
 399                 const auto& otherNodeItem = static_cast<const CNodeItem&>(pOtherPin->GetNodeItem());
 400                 if (otherNodeItem.GetComponentInterface().CanBeParent(&m_nodeItem.GetComponentInterface()))
 401                         return true;
 402         }
 403         return false;
 404 }
 405
 406 bool CChildPinItem::CanConnect(const CryGraphEditor::CAbstractPinItem* pOtherPin) const
 407 {
 408         return !pOtherPin || (pOtherPin->IsInputPin() && pOtherPin->CanConnect(this));
 409 }
 410
 411 CFeatureItem::CFeatureItem(pfx2::IParticleFeature& feature, CNodeItem& node, CryGraphEditor::CNodeGraphViewModel& viewModel)
 412         : CAbstractNodeGraphViewModelItem(viewModel)
 413         , m_featureInterface(feature)
 414         , m_node(node)
 415 {
 416         m_pPin = HasComponentConnector() ? new CFeaturePinItem(*this) : nullptr;
 417
 418         SetAcceptsDeactivation(true);
 419         SetAcceptsHighlightning(true);
 420         SetAcceptsSelection(true);
 421 }
 422
 423 CFeatureItem::~CFeatureItem()
 424 {
 425         delete m_pPin;
 426 }
 427
 428 bool CFeatureItem::IsDeactivated() const
 429 {
 430         return m_featureInterface.IsEnabled() == false;
 431 }
 432
 433 void CFeatureItem::SetDeactivated(bool isDeactivated)
 434 {
 435         if (!m_featureInterface.IsEnabled() != isDeactivated)
 436         {
 437                 m_featureInterface.SetEnabled(!isDeactivated);
 438                 m_node.GetComponentInterface().SetChanged();
 439                 SignalItemDeactivatedChanged(isDeactivated);
 440
 441                 // Note: Property tree listens only to node properties changed
 442                 //                       events. So at least for now we need to invalidate the whole node.
 443                 m_node.SignalInvalidated();
 444                 m_node.OnChanged();
 445         }
 446 }
 447
 448 void CFeatureItem::Serialize(Serialization::IArchive& archive)
 449 {
 450         pfx2::IParticleComponent& component = GetNodeItem().GetComponentInterface();
 451         Serialization::SContext context(archive, &component);
 452         m_featureInterface.Serialize(archive);
 453         if (archive.isInput())
 454         {
 455                 component.SetChanged();
 456                 SignalInvalidated();
 457         }
 458 }
 459
 460 QString CFeatureItem::GetGroupName() const
 461 {
 462         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 463         return QString(params.m_groupName);
 464 }
 465
 466 QString CFeatureItem::GetName() const
 467 {
 468         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 469         return QString(params.m_featureName);
 470 }
 471
 472 uint32 CFeatureItem::GetIndex() const
 473 {
 474         pfx2::IParticleComponent& component = m_node.GetComponentInterface();
 475
 476         for (uint32 i = 0; i < component.GetNumFeatures(); ++i)
 477         {
 478                 if (component.GetFeature(i) == &m_featureInterface)
 479                 {
 480                         return i;
 481                 }
 482         }
 483
 484         CRY_ASSERT_MESSAGE(0, "Invalid feature item!");
 485         return ~0;
 486 }
 487
 488 bool CFeatureItem::HasComponentConnector() const
 489 {
 490         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 491         return params.m_hasComponentConnector;
 492 }
 493
 494 QColor CFeatureItem::GetColor() const
 495 {
 496         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 497         return QColor(params.m_color.r, params.m_color.g, params.m_color.b);
 498 }
 499
 500 CConnectionItem::CConnectionItem(CBasePinItem& sourcePin, CBasePinItem& targetPin, CryGraphEditor::CNodeGraphViewModel& viewModel)
 501         : CryGraphEditor::CAbstractConnectionItem(sourcePin, targetPin, viewModel)
 502 {
 503         sourcePin.AddConnection(*this);
 504         targetPin.AddConnection(*this);
 505
 506         string sourceNodeName = QtUtil::ToString(sourcePin.GetNodeItem().GetName());
 507         string sourceNodePin = QtUtil::ToString(sourcePin.GetName());
 508         string targetNodeName = QtUtil::ToString(targetPin.GetNodeItem().GetName());
 509         string targetNodePin = QtUtil::ToString(targetPin.GetName());
 510
 511         string id;
 512         id.Format("%s-%s::%s-%s", sourceNodeName, sourceNodePin, targetNodeName, targetNodePin);
 513
 514         m_id = CCrc32::Compute(id.c_str());
 515 }
 516
 517 CryGraphEditor::CConnectionWidget* CConnectionItem::CreateWidget(CryGraphEditor::CNodeGraphView& view)
 518 {
 519         return new CryGraphEditor::CConnectionWidget(this, view);
 520 }
 521
 522 QVariant CConnectionItem::GetId() const
 523 {
 524         return QVariant::fromValue(m_id);
 525 }
 526
 527 bool CConnectionItem::HasId(QVariant id) const
 528 {
 529         return (GetId().value<uint32>() == id.value<uint32>());
 530 }
 531
 532 void CConnectionItem::OnConnectionRemoved()
 533 {
 534         GetSourcePinItem().RemoveConnection(*this);
 535         GetTargetPinItem().RemoveConnection(*this);
 536 }
 537
 538 }