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

   1 // Copyright 2001-2018 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
 129                 // TODO: Move this into an CAbstractNodeItem method.
 130                 if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 131                 {
 132                         CUndo::Record(new CryGraphEditor::CUndoNodeNameChange(*this, oldName.c_str()));
 133                 }
 134                 // ~TODO
 135         }
 136 }
 137
 138 bool CNodeItem::IsDeactivated() const
 139 {
 140         return !m_component.IsEnabled();
 141 }
 142
 143 void CNodeItem::SetDeactivated(bool isDeactivated)
 144 {
 145         if (IsDeactivated() != isDeactivated)
 146         {
 147                 m_component.SetEnabled(!isDeactivated);
 148                 SignalDeactivatedChanged(isDeactivated);
 149                 static_cast<CParticleGraphModel*>(&GetViewModel())->OnNodeItemChanged(this);
 150         }
 151 }
 152
 153 void CNodeItem::Serialize(Serialization::IArchive& archive)
 154 {
 155         const string oldName = m_component.GetName();
 156
 157         m_component.Serialize(archive);
 158
 159         // Note: Update everything.
 160         const uint32 numFeatures = m_component.GetNumFeatures();
 161         FeatureItemArray features;
 162         features.reserve(numFeatures);
 163         CryGraphEditor::PinItemArray pins;
 164         pins.push_back(m_pins[0]);
 165         pins.push_back(m_pins[1]);
 166
 167         size_t movedFeatures = 0;
 168
 169         for (uint32 i = 0; i < numFeatures; ++i)
 170         {
 171                 pfx2::IParticleFeature* pFeatureInterface = m_component.GetFeature(i);
 172                 auto predicate = [pFeatureInterface](CFeatureItem* pFeatureItem) -> bool
 173                 {
 174                         return (pFeatureItem && pFeatureInterface == &pFeatureItem->GetFeatureInterface());
 175                 };
 176
 177                 auto result = std::find_if(m_features.begin(), m_features.end(), predicate);
 178                 if (result == m_features.end())
 179                 {
 180                         CFeatureItem* pFeatureItem = new CFeatureItem(*pFeatureInterface, *this, GetViewModel());
 181                         features.push_back(pFeatureItem);
 182                         if (pFeatureItem->HasComponentConnector())
 183                         {
 184                                 pins.push_back(pFeatureItem->GetPinItem());
 185                         }
 186
 187                         SignalFeatureAdded(*pFeatureItem);
 188                 }
 189                 else
 190                 {
 191                         CFeatureItem* pFeatureItem = *result;
 192                         features.push_back(pFeatureItem);
 193                         if (pFeatureItem->HasComponentConnector())
 194                         {
 195                                 pins.push_back(pFeatureItem->GetPinItem());
 196                         }
 197
 198                         pFeatureItem->SignalInvalidated();
 199                         *result = nullptr;
 200                         ++movedFeatures;
 201                 }
 202         }
 203
 204         for (size_t i = 0; i < m_features.size(); ++i)
 205         {
 206                 if (m_features[i] != nullptr)
 207                         RemoveFeature(i);
 208         }
 209
 210         CRY_ASSERT(m_features.size() == movedFeatures);
 211
 212         m_features.swap(features);
 213         m_pins.swap(pins);
 214
 215         CRY_ASSERT(m_features.size() == numFeatures);
 216
 217         SignalInvalidated();
 218 }
 219
 220 CParentPinItem* CNodeItem::GetParentPinItem()
 221 {
 222         return static_cast<CParentPinItem*>(m_pins[0]);
 223 }
 224
 225 CChildPinItem* CNodeItem::GetChildPinItem()
 226 {
 227         return static_cast<CChildPinItem*>(m_pins[1]);
 228 }
 229
 230 uint32 CNodeItem::GetIndex() const
 231 {
 232         CParticleGraphModel& model = static_cast<CParticleGraphModel&>(GetViewModel());
 233         const pfx2::IParticleEffectPfx2& effect = model.GetEffectInterface();
 234
 235         const uint32 numNodes = effect.GetNumComponents();
 236         for (uint32 i = 0; i < numNodes; ++i)
 237         {
 238                 if (effect.GetComponent(i) == &m_component)
 239                         return i;
 240         }
 241
 242         return ~0;
 243 }
 244
 245 CFeatureItem* CNodeItem::AddFeature(uint32 index, const pfx2::SParticleFeatureParams& featureParams)
 246 {
 247         m_component.AddFeature(index, featureParams);
 248
 249         pfx2::IParticleFeature* pFeature = m_component.GetFeature(index);
 250         if (pFeature)
 251         {
 252                 CFeatureItem* pFeatureItem = new CFeatureItem(*pFeature, *this, GetViewModel());
 253                 m_features.insert(m_features.begin() + index, pFeatureItem);
 254                 if (pFeatureItem->HasComponentConnector())
 255                 {
 256                         m_pins.push_back(pFeatureItem->GetPinItem());
 257                 }
 258                 SignalFeatureAdded(*pFeatureItem);
 259
 260                 if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 261                 {
 262                         CUndo::Record(new CUndoFeatureCreate(*pFeatureItem));
 263                 }
 264
 265                 return pFeatureItem;
 266         }
 267         return nullptr;
 268 }
 269
 270 void CNodeItem::RemoveFeature(uint32 index)
 271 {
 272         if (m_features.size() > index)
 273         {
 274                 CFeatureItem* pFeatureItem = m_features.at(index);
 275
 276                 GetViewModel().SignalRemoveCustomItem(*pFeatureItem);
 277                 SignalFeatureRemoved(*pFeatureItem);
 278
 279                 m_features.erase(m_features.begin() + index);
 280
 281                 if (CFeaturePinItem* pFeaturePinItem = pFeatureItem->GetPinItem())
 282                 {
 283                         if (pFeaturePinItem->IsConnected())
 284                         {
 285                                 CParticleGraphModel& model = static_cast<CParticleGraphModel&>(GetViewModel());
 286                                 for (CryGraphEditor::CAbstractConnectionItem* pConnectionItem : pFeaturePinItem->GetConnectionItems())
 287                                 {
 288                                         model.RemoveConnection(*pConnectionItem);
 289                                 }
 290                         }
 291                         auto result = std::find(m_pins.begin(), m_pins.end(), pFeatureItem->GetPinItem());
 292                         CRY_ASSERT(result != m_pins.end());
 293                         m_pins.erase(result);
 294                 }
 295
 296                 if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 297                         CUndo::Record(new CUndoFeatureRemove(*pFeatureItem));
 298
 299                 delete pFeatureItem;
 300         }
 301
 302         if (index < m_component.GetNumFeatures())
 303                 m_component.RemoveFeature(index);
 304 }
 305
 306 bool CNodeItem::MoveFeatureAtIndex(uint32 featureIndex, uint32 destIndex)
 307 {
 308         const uint32 maxIndex = m_features.size() - 1;
 309         destIndex = std::min(destIndex, maxIndex);
 310         if (featureIndex != destIndex)
 311         {
 312                 const size_t numFeatures = m_features.size();
 313                 std::vector<uint32> ids;
 314                 ids.reserve(m_features.size());
 315
 316                 for (size_t i = 0; i < numFeatures; ++i)
 317                         ids.push_back(i);
 318
 319                 CFeatureItem* pFeatureItem = m_features[featureIndex];
 320
 321                 ids.erase(ids.begin() + featureIndex);
 322                 ids.insert(ids.begin() + destIndex, featureIndex);
 323
 324                 m_component.SwapFeatures(&ids[0], ids.size());
 325
 326                 m_features.erase(m_features.begin() + featureIndex);
 327                 m_features.insert(m_features.begin() + destIndex, pFeatureItem);
 328
 329                 if (m_component.GetFeature(destIndex) == &pFeatureItem->GetFeatureInterface())
 330                 {
 331                         SignalFeatureMoved(*pFeatureItem);
 332                         if (GetIEditor()->GetIUndoManager()->IsUndoRecording())
 333                         {
 334                                 CUndo::Record(new CUndoFeatureMove(*pFeatureItem, featureIndex));
 335                                 return true;
 336                         }
 337                 }
 338         }
 339         return false;
 340 }
 341
 342 void CNodeItem::SetVisible(bool isVisible)
 343 {
 344         if (isVisible != m_component.IsVisible())
 345         {
 346                 m_component.SetVisible(isVisible);
 347                 SignalVisibleChanged(isVisible);
 348                 static_cast<CParticleGraphModel*>(&GetViewModel())->OnNodeItemChanged(this);
 349         }
 350 }
 351
 352 bool CNodeItem::IsVisible()
 353 {
 354         return m_component.IsVisible();
 355 }
 356
 357 CFeaturePinItem::CFeaturePinItem(CFeatureItem& feature)
 358         : CBasePinItem(feature.GetNodeItem())
 359         , m_featureItem(feature)
 360 {
 361 }
 362
 363 QString CFeaturePinItem::GetName() const
 364 {
 365         return m_featureItem.GetName();
 366 }
 367
 368 QVariant CFeaturePinItem::GetId() const
 369 {
 370         return QVariant::fromValue(m_featureItem.GetName());
 371 }
 372
 373 bool CFeaturePinItem::HasId(QVariant id) const
 374 {
 375         return (m_featureItem.GetName() == id.value<QString>());
 376 }
 377
 378 bool CFeaturePinItem::CanConnect(const CryGraphEditor::CAbstractPinItem* pOtherPin) const
 379 {
 380         if (pOtherPin)
 381                 return pOtherPin->IsInputPin() && !pOtherPin->IsConnected();
 382
 383         return true;
 384 }
 385
 386 CFeatureItem::CFeatureItem(pfx2::IParticleFeature& feature, CNodeItem& node, CryGraphEditor::CNodeGraphViewModel& viewModel)
 387         : CAbstractNodeGraphViewModelItem(viewModel)
 388         , m_featureInterface(feature)
 389         , m_node(node)
 390 {
 391         m_pPin = HasComponentConnector() ? new CFeaturePinItem(*this) : nullptr;
 392
 393         SetAcceptsDeactivation(true);
 394         SetAcceptsHighlightning(true);
 395         SetAcceptsSelection(true);
 396 }
 397
 398 CFeatureItem::~CFeatureItem()
 399 {
 400         delete m_pPin;
 401 }
 402
 403 bool CFeatureItem::IsDeactivated() const
 404 {
 405         return m_featureInterface.IsEnabled() == false;
 406 }
 407
 408 void CFeatureItem::SetDeactivated(bool isDeactivated)
 409 {
 410         if (!m_featureInterface.IsEnabled() != isDeactivated)
 411         {
 412                 m_featureInterface.SetEnabled(!isDeactivated);
 413                 m_node.GetComponentInterface().SetChanged();
 414                 SignalItemDeactivatedChanged(isDeactivated);
 415
 416                 // Note: Property tree listens only to node properties changed
 417                 //                       events. So at least for now we need to invalidate the whole node.
 418                 m_node.SignalInvalidated();
 419                 static_cast<CParticleGraphModel*>(&GetViewModel())->OnNodeItemChanged(&m_node);
 420         }
 421 }
 422
 423 void CFeatureItem::Serialize(Serialization::IArchive& archive)
 424 {
 425         pfx2::IParticleComponent& component = GetNodeItem().GetComponentInterface();
 426         Serialization::SContext context(archive, &component);
 427         m_featureInterface.Serialize(archive);
 428         if (archive.isInput())
 429         {
 430                 component.SetChanged();
 431                 SignalInvalidated();
 432         }
 433 }
 434
 435 QString CFeatureItem::GetGroupName() const
 436 {
 437         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 438         return QString(params.m_groupName);
 439 }
 440
 441 QString CFeatureItem::GetName() const
 442 {
 443         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 444         return QString(params.m_featureName);
 445 }
 446
 447 uint32 CFeatureItem::GetIndex() const
 448 {
 449         pfx2::IParticleComponent& component = m_node.GetComponentInterface();
 450
 451         for (uint32 i = 0; i < component.GetNumFeatures(); ++i)
 452         {
 453                 if (component.GetFeature(i) == &m_featureInterface)
 454                 {
 455                         return i;
 456                 }
 457         }
 458
 459         CRY_ASSERT_MESSAGE(0, "Invalid feature item!");
 460         return ~0;
 461 }
 462
 463 bool CFeatureItem::HasComponentConnector() const
 464 {
 465         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 466         return params.m_hasComponentConnector;
 467 }
 468
 469 QColor CFeatureItem::GetColor() const
 470 {
 471         const pfx2::SParticleFeatureParams& params = m_featureInterface.GetFeatureParams();
 472         return QColor(params.m_color.r, params.m_color.g, params.m_color.b);
 473 }
 474
 475 CConnectionItem::CConnectionItem(CBasePinItem& sourcePin, CBasePinItem& targetPin, CryGraphEditor::CNodeGraphViewModel& viewModel)
 476         : CryGraphEditor::CAbstractConnectionItem(viewModel)
 477         , m_sourcePin(sourcePin)
 478         , m_targetPin(targetPin)
 479 {
 480         m_sourcePin.AddConnection(*this);
 481         m_targetPin.AddConnection(*this);
 482
 483         string sourceNodeName = QtUtil::ToString(m_sourcePin.GetNodeItem().GetName());
 484         string sourceNodePin = QtUtil::ToString(m_sourcePin.GetName());
 485         string targetNodeName = QtUtil::ToString(m_targetPin.GetNodeItem().GetName());
 486         string targetNodePin = QtUtil::ToString(m_targetPin.GetName());
 487
 488         string id;
 489         id.Format("%s-%s::%s-%s", sourceNodeName, sourceNodePin, targetNodeName, targetNodePin);
 490
 491         m_id = CCrc32::Compute(id.c_str());
 492 }
 493
 494 CConnectionItem::~CConnectionItem()
 495 {
 496
 497 }
 498
 499 CryGraphEditor::CConnectionWidget* CConnectionItem::CreateWidget(CryGraphEditor::CNodeGraphView& view)
 500 {
 501         return new CryGraphEditor::CConnectionWidget(this, view);
 502 }
 503
 504 QVariant CConnectionItem::GetId() const
 505 {
 506         return QVariant::fromValue(m_id);
 507 }
 508
 509 bool CConnectionItem::HasId(QVariant id) const
 510 {
 511         return (GetId().value<uint32>() == id.value<uint32>());
 512 }
 513
 514 void CConnectionItem::OnConnectionRemoved()
 515 {
 516         m_sourcePin.RemoveConnection(*this);
 517         m_targetPin.RemoveConnection(*this);
 518 }
 519
 520 }