TrackViewNodes.cpp 86 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560
  1. /*
  2. * Copyright (c) Contributors to the Open 3D Engine Project.
  3. * For complete copyright and license terms please see the LICENSE at the root of this distribution.
  4. *
  5. * SPDX-License-Identifier: Apache-2.0 OR MIT
  6. *
  7. */
  8. // Description : TrackView's tree control.
  9. #include "EditorDefs.h"
  10. #include "TrackViewNodes.h"
  11. // Qt
  12. #include <QAction>
  13. #include <QCompleter>
  14. #include <QDropEvent>
  15. #include <QFileDialog>
  16. #include <QInputDialog>
  17. #include <QMenu>
  18. #include <QMessageBox>
  19. #include <QMimeData>
  20. #include <QScrollBar>
  21. #include <QStyledItemDelegate>
  22. // AzToolsFramework
  23. #include <AzToolsFramework/Entity/EditorEntitySearchBus.h>
  24. #include <AzToolsFramework/ToolsComponents/GenericComponentWrapper.h>
  25. #include <AzCore/std/containers/map.h>
  26. // AzQtComponents
  27. #include <AzQtComponents/Components/InputDialog.h>
  28. #include <AzQtComponents/Components/Widgets/ColorPicker.h>
  29. #include <AzQtComponents/Components/Widgets/FileDialog.h>
  30. // CryCommon
  31. #include <CryCommon/Maestro/Bus/EditorSequenceComponentBus.h>
  32. #include <CryCommon/Maestro/Types/AnimValueType.h>
  33. #include <CryCommon/Maestro/Types/AnimNodeType.h>
  34. #include <CryCommon/Maestro/Types/AnimParamType.h>
  35. #include <CryCommon/Maestro/Types/SequenceType.h>
  36. // Editor
  37. #include "TrackView/TVEventsDialog.h"
  38. #include "TrackView/TrackViewDialog.h"
  39. #include "Util/AutoDirectoryRestoreFileDialog.h"
  40. #include "TrackViewFBXImportPreviewDialog.h"
  41. #include "AnimationContext.h"
  42. CTrackViewNodesCtrl::CRecord::CRecord(CTrackViewNode* pNode /*= nullptr*/)
  43. : m_pNode(pNode)
  44. , m_bVisible(false)
  45. {
  46. if (pNode)
  47. {
  48. QVariant v;
  49. v.setValue<CTrackViewNodePtr>(pNode);
  50. setData(0, Qt::UserRole, v);
  51. }
  52. }
  53. class CTrackViewNodesCtrlDelegate
  54. : public QStyledItemDelegate
  55. {
  56. public:
  57. CTrackViewNodesCtrlDelegate(QObject* parent = nullptr)
  58. : QStyledItemDelegate(parent)
  59. {}
  60. void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override
  61. {
  62. bool enabled = index.data(CTrackViewNodesCtrl::CRecord::EnableRole).toBool();
  63. QStyleOptionViewItem opt = option;
  64. if (!enabled)
  65. {
  66. opt.state &= ~QStyle::State_Enabled;
  67. }
  68. QStyledItemDelegate::paint(painter, opt, index);
  69. }
  70. };
  71. class CTrackViewNodesTreeWidget
  72. : public QTreeWidget
  73. {
  74. public:
  75. CTrackViewNodesTreeWidget(QWidget* parent)
  76. : QTreeWidget(parent)
  77. , m_controller(nullptr)
  78. {
  79. setItemDelegate(new CTrackViewNodesCtrlDelegate(this));
  80. }
  81. void setController(CTrackViewNodesCtrl* p)
  82. {
  83. m_controller = p;
  84. }
  85. protected:
  86. // Allow both CopyActions and MoveActions to be valid drag and drop operations.
  87. Qt::DropActions supportedDropActions() const override
  88. {
  89. return Qt::CopyAction | Qt::MoveAction;
  90. }
  91. void dragMoveEvent(QDragMoveEvent* event) override
  92. {
  93. CTrackViewNodesCtrl::CRecord* record = (CTrackViewNodesCtrl::CRecord*) itemAt(event->pos());
  94. if (!record)
  95. {
  96. return;
  97. }
  98. CTrackViewNode* pTargetNode = record->GetNode();
  99. QTreeWidget::dragMoveEvent(event);
  100. if (!event->isAccepted())
  101. {
  102. return;
  103. }
  104. if (pTargetNode && pTargetNode->IsGroupNode() /*&& !m_draggedNodes.DoesContain(pTargetNode)*/)
  105. {
  106. CTrackViewAnimNode* pDragTarget = static_cast<CTrackViewAnimNode*>(pTargetNode);
  107. bool bAllValidReparenting = true;
  108. QList<CTrackViewAnimNode*> nodes = draggedNodes(event);
  109. Q_FOREACH(CTrackViewAnimNode * pDraggedNode, nodes)
  110. {
  111. if (!pDraggedNode->IsValidReparentingTo(pDragTarget))
  112. {
  113. bAllValidReparenting = false;
  114. break;
  115. }
  116. }
  117. if (!(bAllValidReparenting && !nodes.isEmpty()))
  118. {
  119. event->ignore();
  120. }
  121. return;
  122. }
  123. }
  124. void dropEvent(QDropEvent* event) override
  125. {
  126. CTrackViewNodesCtrl::CRecord* record = (CTrackViewNodesCtrl::CRecord*) itemAt(event->pos());
  127. if (!record)
  128. {
  129. return;
  130. }
  131. CTrackViewNode* targetNode = record->GetNode();
  132. if (targetNode && targetNode->IsGroupNode())
  133. {
  134. CTrackViewAnimNode* dragTarget = static_cast<CTrackViewAnimNode*>(targetNode);
  135. bool allValidReparenting = true;
  136. QList<CTrackViewAnimNode*> nodes = draggedNodes(event);
  137. Q_FOREACH(CTrackViewAnimNode * draggedNode, nodes)
  138. {
  139. if (!draggedNode->IsValidReparentingTo(dragTarget))
  140. {
  141. allValidReparenting = false;
  142. break;
  143. }
  144. }
  145. if (allValidReparenting && !nodes.isEmpty())
  146. {
  147. // By default here the drop action is a CopyAction. That is what we want in case
  148. // some other random control accepts this drop (and then does nothing with the data).
  149. // If that happens we will not receive any notifications. If the Action default was MoveAction,
  150. // the dragged items in the tree would be deleted out from under us causing a crash.
  151. // Since we are here, we know this drop is on the same control so we can
  152. // switch it to a MoveAction right now. The node parents will be fixed up below.
  153. event->setDropAction(Qt::MoveAction);
  154. QTreeWidget::dropEvent(event);
  155. if (!event->isAccepted())
  156. {
  157. return;
  158. }
  159. if (nodes.size() > 0)
  160. {
  161. // All nodes are from the same sequence
  162. CTrackViewSequence* sequence = nodes[0]->GetSequence();
  163. AZ_Assert(nullptr != sequence, "GetSequence() should never be null");
  164. AzToolsFramework::ScopedUndoBatch undoBatch("Drag and Drop Track View Nodes");
  165. Q_FOREACH(CTrackViewAnimNode * draggedNode, nodes)
  166. {
  167. draggedNode->SetNewParent(dragTarget);
  168. undoBatch.MarkEntityDirty(sequence->GetSequenceComponentEntityId());
  169. }
  170. }
  171. }
  172. }
  173. }
  174. void keyPressEvent(QKeyEvent* event) override
  175. {
  176. // HAVE TO INCLUDE CASES FOR THESE IN THE ShortcutOverride handler in ::event() below
  177. switch (event->key())
  178. {
  179. case Qt::Key_Tab:
  180. if (m_controller)
  181. {
  182. m_controller->ShowNextResult();
  183. event->accept();
  184. }
  185. return;
  186. default:
  187. break;
  188. }
  189. QTreeWidget::keyPressEvent(event);
  190. }
  191. bool event(QEvent* e) override
  192. {
  193. if (e->type() == QEvent::ShortcutOverride)
  194. {
  195. // since we respond to the following things, let Qt know so that shortcuts don't override us
  196. bool respondsToEvent = false;
  197. QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
  198. if (keyEvent->key() == Qt::Key_Tab)
  199. {
  200. respondsToEvent = true;
  201. }
  202. if (respondsToEvent)
  203. {
  204. e->accept();
  205. return true;
  206. }
  207. }
  208. return QTreeWidget::event(e);
  209. }
  210. bool focusNextPrevChild([[maybe_unused]] bool next) override
  211. {
  212. return false; // so we get the tab key
  213. }
  214. private:
  215. QList<CTrackViewAnimNode*> draggedNodes(QDropEvent* event)
  216. {
  217. QByteArray encoded = event->mimeData()->data("application/x-qabstractitemmodeldatalist");
  218. QDataStream stream(&encoded, QIODevice::ReadOnly);
  219. QList<CTrackViewAnimNode*> nodes;
  220. while (!stream.atEnd())
  221. {
  222. int row, col;
  223. QMap<int, QVariant> roleDataMap;
  224. stream >> row >> col >> roleDataMap;
  225. QVariant v = roleDataMap[Qt::UserRole];
  226. if (v.isValid())
  227. {
  228. CTrackViewNode* pNode = v.value<CTrackViewNodePtr>();
  229. if (pNode && pNode->GetNodeType() == eTVNT_AnimNode)
  230. {
  231. nodes << (CTrackViewAnimNode*)pNode;
  232. }
  233. }
  234. }
  235. return nodes;
  236. }
  237. CTrackViewNodesCtrl* m_controller;
  238. };
  239. QDataStream& operator<<(QDataStream& out, const CTrackViewNodePtr& obj)
  240. {
  241. out.writeRawData((const char*) &obj, sizeof(obj));
  242. return out;
  243. }
  244. QDataStream& operator>>(QDataStream& in, CTrackViewNodePtr& obj)
  245. {
  246. in.readRawData((char*) &obj, sizeof(obj));
  247. return in;
  248. }
  249. enum EMenuItem
  250. {
  251. eMI_SelectInViewport = 603,
  252. eMI_CopyNodes = 605,
  253. eMI_CopySelectedNodes = 602,
  254. eMI_PasteNodes = 604,
  255. eMI_RemoveSelected = 10,
  256. eMI_CopyKeys = 599,
  257. eMI_CopySelectedKeys = 600,
  258. eMI_PasteKeys = 601,
  259. eMI_AddTrackBase = 1000,
  260. eMI_RemoveTrack = 299,
  261. eMI_ExpandAll = 650,
  262. eMI_CollapseAll = 659,
  263. eMI_ExpandFolders = 660,
  264. eMI_CollapseFolders = 661,
  265. eMI_ExpandEntities = 651,
  266. eMI_CollapseEntities = 652,
  267. eMI_ExpandCameras = 653,
  268. eMI_CollapseCameras = 654,
  269. eMI_ExpandEvents = 657,
  270. eMI_CollapseEvents = 658,
  271. eMI_Rename = 11,
  272. eMI_CreateFolder = 610,
  273. eMI_AddSelectedEntities = 500,
  274. eMI_AddDirectorNode = 501,
  275. eMI_AddConsoleVariable = 502,
  276. eMI_AddScriptVariable = 503,
  277. eMI_AddEvent = 505,
  278. eMI_AddCurrentLayer = 506,
  279. eMI_AddCommentNode = 507,
  280. eMI_AddRadialBlur = 508,
  281. eMI_AddColorCorrection = 509,
  282. eMI_AddDOF = 510,
  283. eMI_AddScreenfader = 511,
  284. eMI_AddShadowSetup = 513,
  285. eMI_EditEvents = 550,
  286. eMI_SaveToFBX = 12,
  287. eMI_ImportFromFBX = 14,
  288. eMI_SetAsViewCamera = 13,
  289. eMI_SetAsActiveDirector = 15,
  290. eMI_Disable = 17,
  291. eMI_Mute = 18,
  292. eMI_CustomizeTrackColor = 19,
  293. eMI_ClearCustomTrackColor = 20,
  294. eMI_ShowHideBase = 100,
  295. eMI_SelectSubmaterialBase = 2000,
  296. eMI_SetAnimationLayerBase = 3000,
  297. };
  298. // The 'MI' represents a Menu Item.
  299. AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
  300. #include <TrackView/ui_TrackViewNodes.h>
  301. AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
  302. CTrackViewNodesCtrl::CTrackViewNodesCtrl(QWidget* hParentWnd, CTrackViewDialog* parent /* = 0 */)
  303. : QWidget(hParentWnd)
  304. , m_bIgnoreNotifications(false)
  305. , m_bNeedReload(false)
  306. , m_bSelectionChanging(false)
  307. , ui(new Ui::CTrackViewNodesCtrl)
  308. , m_pTrackViewDialog(parent)
  309. {
  310. ui->setupUi(this);
  311. m_pDopeSheet = nullptr;
  312. m_currentMatchIndex = 0;
  313. m_matchCount = 0;
  314. qRegisterMetaType<CTrackViewNodePtr>("CTrackViewNodePtr");
  315. qRegisterMetaTypeStreamOperators<CTrackViewNodePtr>("CTrackViewNodePtr");
  316. ui->treeWidget->hide();
  317. ui->searchField->hide();
  318. ui->searchCount->hide();
  319. ui->searchField->installEventFilter(this);
  320. ui->treeWidget->setController(this);
  321. ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
  322. connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this, &CTrackViewNodesCtrl::OnNMRclick);
  323. connect(ui->treeWidget, &QTreeWidget::itemExpanded, this, &CTrackViewNodesCtrl::OnItemExpanded);
  324. connect(ui->treeWidget, &QTreeWidget::itemCollapsed, this, &CTrackViewNodesCtrl::OnItemExpanded);
  325. connect(ui->treeWidget, &QTreeWidget::itemSelectionChanged, this, &CTrackViewNodesCtrl::OnSelectionChanged);
  326. connect(ui->treeWidget, &QTreeWidget::itemDoubleClicked, this, &CTrackViewNodesCtrl::OnItemDblClick);
  327. connect(ui->searchField, &QLineEdit::textChanged, this, &CTrackViewNodesCtrl::OnFilterChange);
  328. m_bEditLock = false;
  329. m_arrowCursor = Qt::ArrowCursor;
  330. m_noIcon = Qt::ForbiddenCursor;
  331. ///////////////////////////////////////////////////////////////
  332. // Populate m_componentTypeToIconMap with all component icons
  333. AZ::SerializeContext* serializeContext = nullptr;
  334. AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
  335. AZ_Assert(serializeContext, "Failed to acquire serialize context.");
  336. serializeContext->EnumerateDerived<AZ::Component>([this](const AZ::SerializeContext::ClassData* classData, const AZ::Uuid&) -> bool
  337. {
  338. AZStd::string iconPath;
  339. AzToolsFramework::EditorRequestBus::BroadcastResult(iconPath, &AzToolsFramework::EditorRequests::GetComponentTypeEditorIcon, classData->m_typeId);
  340. if (!iconPath.empty())
  341. {
  342. m_componentTypeToIconMap[classData->m_typeId] = QIcon(iconPath.c_str());
  343. }
  344. return true; // continue enumerating
  345. });
  346. ///////////////////////////////////////////////////////////////
  347. GetIEditor()->GetSequenceManager()->AddListener(this);
  348. GetIEditor()->GetAnimation()->AddListener(this);
  349. GetIEditor()->GetUndoManager()->AddListener(this);
  350. };
  351. CTrackViewNodesCtrl::~CTrackViewNodesCtrl()
  352. {
  353. GetIEditor()->GetUndoManager()->RemoveListener(this);
  354. GetIEditor()->GetAnimation()->RemoveListener(this);
  355. GetIEditor()->GetSequenceManager()->RemoveListener(this);
  356. }
  357. bool CTrackViewNodesCtrl::eventFilter(QObject* o, QEvent* e)
  358. {
  359. if (o == ui->searchField && e->type() == QEvent::KeyPress)
  360. {
  361. QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
  362. if (keyEvent->key() == Qt::Key_Tab && keyEvent->modifiers() == Qt::NoModifier)
  363. {
  364. ShowNextResult();
  365. return true;
  366. }
  367. }
  368. return QWidget::eventFilter(o, e);
  369. }
  370. void CTrackViewNodesCtrl::OnSequenceChanged()
  371. {
  372. AZ_Assert(m_pTrackViewDialog, "m_pTrackViewDialog is null");
  373. m_nodeToRecordMap.clear();
  374. ui->treeWidget->clear();
  375. FillAutoCompletionListForFilter();
  376. Reload();
  377. }
  378. // IAnimationContextListener
  379. void CTrackViewNodesCtrl::OnSequenceChanged([[maybe_unused]]CTrackViewSequence* pNewSequence)
  380. {
  381. OnSequenceChanged();
  382. }
  383. // ITrackViewSequenceManagerListener
  384. void CTrackViewNodesCtrl::OnSequenceRemoved([[maybe_unused]] CTrackViewSequence* pSequence)
  385. {
  386. OnSequenceChanged();
  387. }
  388. void CTrackViewNodesCtrl::SetDopeSheet(CTrackViewDopeSheetBase* pDopeSheet)
  389. {
  390. m_pDopeSheet = pDopeSheet;
  391. }
  392. CTrackViewNodesCtrl::CRecord* CTrackViewNodesCtrl::AddAnimNodeRecord(CRecord* pParentRecord, CTrackViewAnimNode* animNode)
  393. {
  394. CRecord* pNewRecord = new CRecord(animNode);
  395. pNewRecord->setText(0, QString::fromUtf8(animNode->GetName().c_str()));
  396. UpdateAnimNodeRecord(pNewRecord, animNode);
  397. pParentRecord->insertChild(GetInsertPosition(pParentRecord, animNode), pNewRecord);
  398. FillNodesRec(pNewRecord, animNode);
  399. return pNewRecord;
  400. }
  401. CTrackViewNodesCtrl::CRecord* CTrackViewNodesCtrl::AddTrackRecord(CRecord* pParentRecord, CTrackViewTrack* pTrack)
  402. {
  403. CRecord* pNewTrackRecord = new CRecord(pTrack);
  404. pNewTrackRecord->setText(0, QString::fromUtf8(pTrack->GetName().c_str()));
  405. UpdateTrackRecord(pNewTrackRecord, pTrack);
  406. pParentRecord->insertChild(GetInsertPosition(pParentRecord, pTrack), pNewTrackRecord);
  407. FillNodesRec(pNewTrackRecord, pTrack);
  408. return pNewTrackRecord;
  409. }
  410. int CTrackViewNodesCtrl::GetInsertPosition(CRecord* pParentRecord, CTrackViewNode* pNode)
  411. {
  412. // Search for insert position
  413. const int siblingCount = pParentRecord->childCount();
  414. for (int i = 0; i < siblingCount; ++i)
  415. {
  416. CRecord* record = static_cast<CRecord*>(pParentRecord->child(i));
  417. CTrackViewNode* pSiblingNode = record->GetNode();
  418. if (*pNode < *pSiblingNode)
  419. {
  420. return i;
  421. }
  422. }
  423. return siblingCount;
  424. }
  425. void CTrackViewNodesCtrl::AddNodeRecord(CRecord* record, CTrackViewNode* pNode)
  426. {
  427. if (m_nodeToRecordMap.find(pNode) != m_nodeToRecordMap.end())
  428. {
  429. AZ_Assert(false, "Node %p already added to the node to record map", pNode)
  430. // For safety. Shouldn't happen
  431. return;
  432. }
  433. CRecord* pNewRecord = nullptr;
  434. if (pNode->IsHidden())
  435. {
  436. return;
  437. }
  438. switch (pNode->GetNodeType())
  439. {
  440. case eTVNT_AnimNode:
  441. pNewRecord = AddAnimNodeRecord(record, static_cast<CTrackViewAnimNode*>(pNode));
  442. break;
  443. case eTVNT_Track:
  444. pNewRecord = AddTrackRecord(record, static_cast<CTrackViewTrack*>(pNode));
  445. break;
  446. }
  447. if (pNewRecord)
  448. {
  449. if (!pNode->IsGroupNode() && pNode->GetChildCount() == 0) // groups and compound tracks are draggable
  450. {
  451. pNewRecord->setFlags(pNewRecord->flags() & ~Qt::ItemIsDragEnabled);
  452. }
  453. if (!pNode->IsGroupNode()) // only groups can be dropped into
  454. {
  455. pNewRecord->setFlags(pNewRecord->flags() & ~Qt::ItemIsDropEnabled);
  456. }
  457. if (pNode->GetExpanded())
  458. {
  459. pNewRecord->setExpanded(true);
  460. }
  461. if (pNode->IsSelected())
  462. {
  463. m_bIgnoreNotifications = true;
  464. SelectRow(pNode, false, false);
  465. m_bIgnoreNotifications = false;
  466. }
  467. m_nodeToRecordMap[pNode] = pNewRecord;
  468. }
  469. }
  470. void CTrackViewNodesCtrl::FillNodesRec(CRecord* record, CTrackViewNode* pCurrentNode)
  471. {
  472. const unsigned int childCount = pCurrentNode->GetChildCount();
  473. for (unsigned int childIndex = 0; childIndex < childCount; ++childIndex)
  474. {
  475. CTrackViewNode* pNode = pCurrentNode->GetChild(childIndex);
  476. if (!pNode->IsHidden())
  477. {
  478. AddNodeRecord(record, pNode);
  479. }
  480. }
  481. }
  482. void CTrackViewNodesCtrl::UpdateNodeRecord(CRecord* record)
  483. {
  484. CTrackViewNode* pNode = record->GetNode();
  485. if (pNode)
  486. {
  487. switch (pNode->GetNodeType())
  488. {
  489. case eTVNT_AnimNode:
  490. UpdateAnimNodeRecord(record, static_cast<CTrackViewAnimNode*>(pNode));
  491. break;
  492. case eTVNT_Track:
  493. UpdateTrackRecord(record, static_cast<CTrackViewTrack*>(pNode));
  494. break;
  495. }
  496. }
  497. }
  498. void CTrackViewNodesCtrl::UpdateTrackRecord(CRecord* record, CTrackViewTrack* pTrack)
  499. {
  500. record->setIcon(0, GetIconForTrack(pTrack));
  501. // Check if parameter is valid for non sub tracks
  502. CTrackViewAnimNode* animNode = pTrack->GetAnimNode();
  503. const bool isParamValid = pTrack->IsSubTrack() || animNode->IsParamValid(pTrack->GetParameterType());
  504. // Check if disabled or muted
  505. const bool bDisabledOrMuted = pTrack->IsDisabled() || pTrack->IsMuted();
  506. // If track is not valid and disabled/muted color node in grey
  507. record->setData(0, CRecord::EnableRole, !bDisabledOrMuted && isParamValid);
  508. }
  509. void CTrackViewNodesCtrl::UpdateAnimNodeRecord(CRecord* record, CTrackViewAnimNode* animNode)
  510. {
  511. const QColor TextColorForMissingEntity(226, 52, 43); // LY palette for 'Error/Failure'
  512. const QColor BackColorForActiveDirector(243, 81, 29); // LY palette for 'Primary'
  513. const QColor BackColorForInactiveDirector(22, 23, 27); // LY palette for 'Background (In Focus)'
  514. const QColor BackColorForGroupNodes(42, 84, 244); // LY palette for 'Secondary'
  515. QFont f = font();
  516. f.setBold(true);
  517. record->setFont(0, f);
  518. AnimNodeType nodeType = animNode->GetType();
  519. if (nodeType == AnimNodeType::Component)
  520. {
  521. // get the component icon from cached component icons
  522. AZ::Entity* azEntity = nullptr;
  523. AZ::ComponentApplicationBus::BroadcastResult(azEntity, &AZ::ComponentApplicationBus::Events::FindEntity,
  524. static_cast<CTrackViewAnimNode*>(animNode->GetParentNode())->GetAzEntityId());
  525. if (azEntity)
  526. {
  527. const AZ::Component* component = azEntity->FindComponent(animNode->GetComponentId());
  528. if (component)
  529. {
  530. auto findIter = m_componentTypeToIconMap.find(AzToolsFramework::GetUnderlyingComponentType(*component));
  531. if (findIter != m_componentTypeToIconMap.end())
  532. {
  533. record->setIcon(0, findIter->second);
  534. }
  535. }
  536. }
  537. }
  538. else
  539. {
  540. record->setIcon(0, TrackViewNodeIcon(nodeType));
  541. }
  542. const bool disabled = animNode->IsDisabled();
  543. record->setData(0, CRecord::EnableRole, !disabled);
  544. if (nodeType == AnimNodeType::Group)
  545. {
  546. record->setBackground(0, BackColorForGroupNodes);
  547. record->setSizeHint(0, QSize(30, 20));
  548. }
  549. else if (nodeType == AnimNodeType::AzEntity)
  550. {
  551. AZ::Entity* entity = nullptr;
  552. AZ::ComponentApplicationBus::BroadcastResult(
  553. entity, &AZ::ComponentApplicationBus::Events::FindEntity, animNode->GetAzEntityId());
  554. if (!entity)
  555. {
  556. // In case of a missing entity, color it red.
  557. record->setForeground(0, TextColorForMissingEntity);
  558. }
  559. else
  560. {
  561. record->setData(0, Qt::ForegroundRole, QPalette::ColorRole::NoRole);
  562. }
  563. }
  564. // Mark the active director and other directors properly.
  565. if (animNode->IsActiveDirector())
  566. {
  567. record->setBackground(0, BackColorForActiveDirector);
  568. }
  569. else if (nodeType == AnimNodeType::Director)
  570. {
  571. record->setBackground(0, BackColorForInactiveDirector);
  572. }
  573. }
  574. void CTrackViewNodesCtrl::Reload()
  575. {
  576. ui->treeWidget->clear();
  577. OnFillItems();
  578. }
  579. void CTrackViewNodesCtrl::OnFillItems()
  580. {
  581. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  582. if (sequence)
  583. {
  584. CTrackViewSequenceNotificationContext context(sequence);
  585. m_nodeToRecordMap.clear();
  586. CRecord* pRootGroupRec = new CRecord(sequence);
  587. pRootGroupRec->setText(0, QString::fromUtf8(sequence->GetName().c_str()));
  588. QFont f = font();
  589. f.setBold(true);
  590. pRootGroupRec->setData(0, Qt::FontRole, f);
  591. pRootGroupRec->setSizeHint(0, QSize(width(), 24));
  592. m_nodeToRecordMap[sequence] = pRootGroupRec;
  593. ui->treeWidget->addTopLevelItem(pRootGroupRec);
  594. FillNodesRec(pRootGroupRec, sequence);
  595. pRootGroupRec->setExpanded(sequence->GetExpanded());
  596. // Additional empty record like space for scrollbar in key control
  597. CRecord* pGroupRec = new CRecord();
  598. pGroupRec->setSizeHint(0, QSize(width(), 18));
  599. ui->treeWidget->addTopLevelItem(pRootGroupRec);
  600. }
  601. }
  602. void CTrackViewNodesCtrl::OnItemExpanded(QTreeWidgetItem* item)
  603. {
  604. CRecord* record = (CRecord*) item;
  605. if (record && record->GetNode())
  606. {
  607. bool currentlyExpanded = record->GetNode()->GetExpanded();
  608. bool expanded = item->isExpanded();
  609. if (expanded != currentlyExpanded)
  610. {
  611. bool isDuringUndo = false;
  612. AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(isDuringUndo, &AzToolsFramework::ToolsApplicationRequests::Bus::Events::IsDuringUndoRedo);
  613. // Don't record another undo event if this OnItemExpanded callback is fired because we are Undoing or Redoing.
  614. if (isDuringUndo)
  615. {
  616. record->GetNode()->SetExpanded(expanded);
  617. }
  618. else
  619. {
  620. CTrackViewSequence* sequence = record->GetNode()->GetSequence();
  621. AZ_Assert(nullptr != sequence, "Expected valid sequence");
  622. AzToolsFramework::ScopedUndoBatch undoBatch("Set Node Expanded");
  623. record->GetNode()->SetExpanded(expanded);
  624. undoBatch.MarkEntityDirty(sequence->GetSequenceComponentEntityId());
  625. }
  626. }
  627. }
  628. UpdateDopeSheet();
  629. }
  630. void CTrackViewNodesCtrl::OnSelectionChanged()
  631. {
  632. // Need to avoid the second call to this, because GetSelectedRows is broken
  633. // with multi selection
  634. if (m_bSelectionChanging)
  635. {
  636. return;
  637. }
  638. m_bSelectionChanging = true;
  639. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  640. if (sequence)
  641. {
  642. CTrackViewSequenceNotificationContext context(sequence);
  643. sequence->ClearSelection();
  644. QList<QTreeWidgetItem*> items = ui->treeWidget->selectedItems();
  645. int nCount = items.count();
  646. for (int i = 0; i < nCount; i++)
  647. {
  648. CRecord* record = (CRecord*)items.at(i);
  649. if (record && record->GetNode())
  650. {
  651. if (!record->GetNode()->IsSelected())
  652. {
  653. record->GetNode()->SetSelected(true);
  654. ui->treeWidget->setCurrentItem(record);
  655. }
  656. }
  657. }
  658. }
  659. m_bSelectionChanging = false;
  660. UpdateDopeSheet();
  661. }
  662. void CTrackViewNodesCtrl::OnNMRclick(QPoint point)
  663. {
  664. CRecord* record = nullptr;
  665. bool isOnAzEntity = false;
  666. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  667. if (!sequence)
  668. {
  669. return;
  670. }
  671. CTrackViewSequenceNotificationContext context(sequence);
  672. // Find node under mouse.
  673. // Select the item that is at the point myPoint.
  674. record = static_cast<CRecord*>(ui->treeWidget->itemAt(point));
  675. CTrackViewAnimNode* groupNode = nullptr;
  676. CTrackViewNode* pNode = nullptr;
  677. CTrackViewAnimNode* animNode = nullptr;
  678. CTrackViewTrack* pTrack = nullptr;
  679. if (record && record->GetNode())
  680. {
  681. pNode = record->GetNode();
  682. if (pNode)
  683. {
  684. ETrackViewNodeType nodeType = pNode->GetNodeType();
  685. if (nodeType == eTVNT_AnimNode)
  686. {
  687. animNode = static_cast<CTrackViewAnimNode*>(pNode);
  688. isOnAzEntity = (animNode && animNode->GetType() == AnimNodeType::AzEntity);
  689. if (animNode->GetType() == AnimNodeType::Director || animNode->GetType() == AnimNodeType::Group || isOnAzEntity)
  690. {
  691. groupNode = animNode;
  692. }
  693. }
  694. else if (nodeType == eTVNT_Sequence)
  695. {
  696. groupNode = sequence;
  697. }
  698. else if (nodeType == eTVNT_Track)
  699. {
  700. pTrack = static_cast<CTrackViewTrack*>(pNode);
  701. animNode = pTrack->GetAnimNode();
  702. }
  703. }
  704. }
  705. else
  706. {
  707. pNode = sequence;
  708. groupNode = sequence;
  709. record = m_nodeToRecordMap[sequence];
  710. }
  711. int cmd = ShowPopupMenu(point, record);
  712. float scrollPos = SaveVerticalScrollPos();
  713. if (cmd == eMI_RemoveSelected)
  714. {
  715. // If we are about to delete the sequence, cancel the notification
  716. // context, otherwise it will notify on a stale sequence pointer.
  717. if (sequence->IsSelected())
  718. {
  719. context.Cancel();
  720. }
  721. // Let the AZ Undo system manage the nodes on the sequence entity
  722. AzToolsFramework::ScopedUndoBatch undoBatch("Delete Selected Nodes/Tracks");
  723. auto id = sequence->GetSequenceComponentEntityId();
  724. sequence->DeleteSelectedNodes();
  725. undoBatch.MarkEntityDirty(id);
  726. }
  727. if (groupNode)
  728. {
  729. // Group operations applicable to AZEntities and Group Nodes
  730. if (cmd == eMI_ExpandAll)
  731. {
  732. BeginUndoTransaction();
  733. groupNode->GetAllAnimNodes().ExpandAll();
  734. EndUndoTransaction();
  735. }
  736. else if (cmd == eMI_CollapseAll)
  737. {
  738. BeginUndoTransaction();
  739. groupNode->GetAllAnimNodes().CollapseAll();
  740. EndUndoTransaction();
  741. }
  742. if (!isOnAzEntity)
  743. {
  744. // Group operations not applicable to AZEntities
  745. if (cmd == eMI_AddSelectedEntities)
  746. {
  747. AzToolsFramework::ScopedUndoBatch undoBatch("Add Entities to Track View");
  748. CTrackViewAnimNodeBundle addedNodes = groupNode->AddSelectedEntities(m_pTrackViewDialog->GetDefaultTracksForEntityNode());
  749. if (addedNodes.GetCount() > 0)
  750. {
  751. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  752. }
  753. int selectedEntitiesCount = 0;
  754. AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(
  755. selectedEntitiesCount, &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntitiesCount);
  756. // check to make sure all nodes were added and notify user if they weren't
  757. if (addedNodes.GetCount() != static_cast<unsigned int>(selectedEntitiesCount))
  758. {
  759. IMovieSystem* movieSystem = AZ::Interface<IMovieSystem>::Get();
  760. AZStd::string messages = movieSystem ? movieSystem->GetUserNotificationMsgs() : "";
  761. // Create a list of all lines
  762. AZStd::vector<AZStd::string> lines;
  763. AzFramework::StringFunc::Tokenize(messages.c_str(), lines, "\n");
  764. // Truncate very long messages. No information is lost because
  765. // all of these errors will have been logged to the console already.
  766. const int maxLines = 30;
  767. AZStd::string shortMessages;
  768. if (lines.size() > maxLines)
  769. {
  770. int numLines = 0;
  771. for (AZStd::string line : lines)
  772. {
  773. shortMessages += line + "\n";
  774. if (++numLines >= maxLines)
  775. {
  776. break;
  777. }
  778. }
  779. shortMessages += "Message truncated, please see console for a full list of warnings.\n";
  780. }
  781. else
  782. {
  783. shortMessages = messages;
  784. }
  785. if (!shortMessages.empty())
  786. {
  787. QMessageBox::information(this, tr("Track View Warning"), tr(shortMessages.c_str()));
  788. }
  789. // clear the notification log now that we've consumed and presented them.
  790. movieSystem->ClearUserNotificationMsgs();
  791. }
  792. groupNode->BindToEditorObjects();
  793. }
  794. else if (cmd == eMI_AddCurrentLayer)
  795. {
  796. AzToolsFramework::ScopedUndoBatch undoBatch("Add Current Layer to Track View");
  797. groupNode->AddCurrentLayer();
  798. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  799. }
  800. else if (cmd == eMI_AddScreenfader)
  801. {
  802. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Screen Fader Node");
  803. groupNode->CreateSubNode("ScreenFader", AnimNodeType::ScreenFader);
  804. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  805. }
  806. else if (cmd == eMI_AddCommentNode)
  807. {
  808. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Comment Node");
  809. QString commentNodeName = groupNode->GetAvailableNodeNameStartingWith("Comment");
  810. groupNode->CreateSubNode(commentNodeName, AnimNodeType::Comment);
  811. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  812. }
  813. else if (cmd == eMI_AddRadialBlur)
  814. {
  815. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Radial Blur Node");
  816. groupNode->CreateSubNode("RadialBlur", AnimNodeType::RadialBlur);
  817. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  818. }
  819. else if (cmd == eMI_AddColorCorrection)
  820. {
  821. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Color Correction Node");
  822. groupNode->CreateSubNode("ColorCorrection", AnimNodeType::ColorCorrection);
  823. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  824. }
  825. else if (cmd == eMI_AddDOF)
  826. {
  827. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Depth of Field Node");
  828. groupNode->CreateSubNode("DepthOfField", AnimNodeType::DepthOfField);
  829. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  830. }
  831. else if (cmd == eMI_AddShadowSetup)
  832. {
  833. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Shadow Setup Node");
  834. groupNode->CreateSubNode("ShadowsSetup", AnimNodeType::ShadowSetup);
  835. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  836. }
  837. else if (cmd == eMI_AddDirectorNode)
  838. {
  839. QString name = groupNode->GetAvailableNodeNameStartingWith("Director");
  840. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Director Node");
  841. groupNode->CreateSubNode(name, AnimNodeType::Director);
  842. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  843. }
  844. else if (cmd == eMI_AddConsoleVariable)
  845. {
  846. QString stringValue = QInputDialog::getText(this, tr("Console Variable Name"), QString());
  847. if (!stringValue.isEmpty())
  848. {
  849. QString name = groupNode->GetAvailableNodeNameStartingWith(stringValue);
  850. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Console (CVar) Node");
  851. groupNode->CreateSubNode(name, AnimNodeType::CVar);
  852. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  853. }
  854. }
  855. else if (cmd == eMI_AddScriptVariable)
  856. {
  857. QString stringValue = QInputDialog::getText(this, tr("Script Variable Name"), QString());
  858. if (!stringValue.isEmpty())
  859. {
  860. QString name = groupNode->GetAvailableNodeNameStartingWith(stringValue);
  861. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Script Variable Node");
  862. groupNode->CreateSubNode(name, AnimNodeType::ScriptVar);
  863. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  864. }
  865. }
  866. else if (cmd == eMI_AddEvent)
  867. {
  868. QString stringValue = QInputDialog::getText(this, tr("Track Event Name"), QString());
  869. if (!stringValue.isEmpty())
  870. {
  871. AzToolsFramework::ScopedUndoBatch undoBatch("Add Track View Event Node");
  872. groupNode->CreateSubNode(stringValue, AnimNodeType::Event);
  873. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  874. }
  875. }
  876. else if (cmd == eMI_PasteNodes)
  877. {
  878. AzToolsFramework::ScopedUndoBatch undoBatch("Paste Track View Nodes");
  879. groupNode->PasteNodesFromClipboard(this);
  880. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  881. }
  882. else if (cmd == eMI_CreateFolder)
  883. {
  884. CreateFolder(groupNode);
  885. }
  886. else if (cmd == eMI_ExpandFolders)
  887. {
  888. AzToolsFramework::ScopedUndoBatch undoBatch("Expand Track View folders");
  889. groupNode->GetAnimNodesByType(AnimNodeType::Group).ExpandAll();
  890. groupNode->GetAnimNodesByType(AnimNodeType::Director).ExpandAll();
  891. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  892. }
  893. else if (cmd == eMI_CollapseFolders)
  894. {
  895. AzToolsFramework::ScopedUndoBatch undoBatch("Collapse Track View folders");
  896. groupNode->GetAnimNodesByType(AnimNodeType::Group).CollapseAll();
  897. groupNode->GetAnimNodesByType(AnimNodeType::Director).CollapseAll();
  898. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  899. }
  900. else if (cmd == eMI_ExpandEntities)
  901. {
  902. AzToolsFramework::ScopedUndoBatch undoBatch("Expand Track View entities");
  903. groupNode->GetAnimNodesByType(AnimNodeType::AzEntity).ExpandAll();
  904. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  905. }
  906. else if (cmd == eMI_CollapseEntities)
  907. {
  908. AzToolsFramework::ScopedUndoBatch undoBatch("Collapse Track View entities");
  909. groupNode->GetAnimNodesByType(AnimNodeType::AzEntity).CollapseAll();
  910. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  911. }
  912. else if (cmd == eMI_ExpandEvents)
  913. {
  914. AzToolsFramework::ScopedUndoBatch undoBatch("Expand Track View events");
  915. groupNode->GetAnimNodesByType(AnimNodeType::Event).ExpandAll();
  916. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  917. }
  918. else if (cmd == eMI_CollapseEvents)
  919. {
  920. AzToolsFramework::ScopedUndoBatch undoBatch("Collapse Track View events");
  921. groupNode->GetAnimNodesByType(AnimNodeType::Event).CollapseAll();
  922. undoBatch.MarkEntityDirty(groupNode->GetSequence()->GetSequenceComponentEntityId());
  923. }
  924. }
  925. }
  926. if (cmd == eMI_EditEvents)
  927. {
  928. EditEvents();
  929. }
  930. else if (cmd == eMI_Rename)
  931. {
  932. if (animNode || groupNode)
  933. {
  934. CTrackViewAnimNode* animNode2 = static_cast<CTrackViewAnimNode*>(pNode);
  935. QString oldName = QString::fromUtf8(animNode2->GetName().c_str());
  936. AzQtComponents::InputDialog inputDialog(this);
  937. inputDialog.setWindowTitle(tr("Rename Node"));
  938. inputDialog.setTextValue(oldName);
  939. inputDialog.setLabelText("");
  940. inputDialog.SetRegularExpressionValidator("[a-zA-Z0-9_\\-\\_]*");
  941. // Max name length is 512 for a sequence
  942. constexpr int MaxNameLength = 512;
  943. inputDialog.SetMaxLength(MaxNameLength);
  944. // add check for duplicate entity names if this is bound to an Object node
  945. bool checkForDuplicateName = animNode2->IsBoundToEditorObjects();
  946. bool retryRename = false;
  947. QString newName;
  948. do
  949. {
  950. const auto ret = inputDialog.exec();
  951. if (ret == QDialog::Accepted)
  952. {
  953. QString name = inputDialog.textValue();
  954. // Bail out early if user is trying to rename to the same name, can treat as a no-op
  955. if (name == oldName)
  956. {
  957. return;
  958. }
  959. if (checkForDuplicateName)
  960. {
  961. AzToolsFramework::EntitySearchFilter filter;
  962. const auto nameUtf8 = name.toUtf8();
  963. const AZStd::string searchName(nameUtf8.constData(), nameUtf8.length());
  964. filter.m_names.push_back(searchName);
  965. AzToolsFramework::EntityIdList matchingEntities;
  966. AzToolsFramework::EditorEntitySearchBus::BroadcastResult(matchingEntities, &AzToolsFramework::EditorEntitySearchRequests::SearchEntities, filter);
  967. if (!matchingEntities.empty())
  968. {
  969. QMessageBox::warning(this, tr("Entity already exists"), QString(tr("Entity named '%1' already exists.\n\nPlease choose another unique name.")).arg(name));
  970. retryRename = true;
  971. }
  972. else
  973. {
  974. newName = name;
  975. retryRename = false;
  976. }
  977. }
  978. else
  979. {
  980. newName = name;
  981. }
  982. }
  983. else
  984. {
  985. retryRename = false;
  986. }
  987. } while (retryRename);
  988. if(!GetNodeRecord(animNode2)) {
  989. QMessageBox::warning(
  990. this,
  991. tr("Entity does not exist"),
  992. tr("Entity has been deleted.\n\nUnable to rename entity"));
  993. }
  994. else if (!newName.isEmpty())
  995. {
  996. const CTrackViewSequenceManager* sequenceManager = GetIEditor()->GetSequenceManager();
  997. sequenceManager->RenameNode(animNode2, newName.toUtf8().data());
  998. UpdateNodeRecord(record);
  999. }
  1000. }
  1001. }
  1002. else if (cmd == eMI_SetAsActiveDirector)
  1003. {
  1004. if (pNode && pNode->GetNodeType() == eTVNT_AnimNode)
  1005. {
  1006. CTrackViewAnimNode* animNode2 = static_cast<CTrackViewAnimNode*>(pNode);
  1007. animNode2->SetAsActiveDirector();
  1008. }
  1009. }
  1010. else if (cmd >= eMI_AddTrackBase && cmd < eMI_AddTrackBase + 1000)
  1011. {
  1012. if (animNode)
  1013. {
  1014. unsigned int menuId = cmd - eMI_AddTrackBase;
  1015. if (animNode->GetType() != AnimNodeType::AzEntity)
  1016. {
  1017. // add track
  1018. auto findIter = m_menuParamTypeMap.find(menuId);
  1019. if (findIter != m_menuParamTypeMap.end())
  1020. {
  1021. AzToolsFramework::ScopedUndoBatch undoBatch("Add TrackView Track");
  1022. animNode->CreateTrack(findIter->second);
  1023. undoBatch.MarkEntityDirty(animNode->GetSequence()->GetSequenceComponentEntityId());
  1024. }
  1025. }
  1026. }
  1027. }
  1028. else if (cmd == eMI_RemoveTrack)
  1029. {
  1030. if (pTrack)
  1031. {
  1032. AzToolsFramework::ScopedUndoBatch undoBatch("Remove TrackView Track");
  1033. pTrack->GetAnimNode()->RemoveTrack(pTrack);
  1034. undoBatch.MarkEntityDirty(pTrack->GetSequence()->GetSequenceComponentEntityId());
  1035. }
  1036. }
  1037. else if (cmd >= eMI_ShowHideBase && cmd < eMI_ShowHideBase + 100)
  1038. {
  1039. if (animNode)
  1040. {
  1041. unsigned int childIndex = cmd - eMI_ShowHideBase;
  1042. if (childIndex < animNode->GetChildCount())
  1043. {
  1044. CTrackViewNode* pChild = animNode->GetChild(childIndex);
  1045. pChild->SetHidden(!pChild->IsHidden());
  1046. }
  1047. }
  1048. }
  1049. else if (cmd == eMI_CopyKeys)
  1050. {
  1051. sequence->CopyKeysToClipboard(false, true);
  1052. }
  1053. else if (cmd == eMI_CopySelectedKeys)
  1054. {
  1055. sequence->CopyKeysToClipboard(true, true);
  1056. }
  1057. else if (cmd == eMI_PasteKeys)
  1058. {
  1059. CUndo undo("Paste TrackView Keys");
  1060. sequence->PasteKeysFromClipboard(animNode, pTrack);
  1061. }
  1062. else if (cmd == eMI_CopyNodes)
  1063. {
  1064. if (animNode)
  1065. {
  1066. animNode->CopyNodesToClipboard(false, this);
  1067. }
  1068. else
  1069. {
  1070. sequence->CopyNodesToClipboard(false, this);
  1071. }
  1072. }
  1073. else if (cmd == eMI_CopySelectedNodes)
  1074. {
  1075. sequence->CopyNodesToClipboard(true, this);
  1076. }
  1077. else if (cmd == eMI_SelectInViewport)
  1078. {
  1079. CUndo undo("Select TrackView Nodes in Viewport");
  1080. sequence->SelectSelectedNodesInViewport();
  1081. }
  1082. else if (cmd >= eMI_SelectSubmaterialBase && cmd < eMI_SelectSubmaterialBase + 100)
  1083. {
  1084. if (animNode)
  1085. {
  1086. QString matName;
  1087. GetMatNameAndSubMtlIndexFromName(matName, animNode->GetName().c_str());
  1088. QString newMatName;
  1089. newMatName = tr("%1.[%2]").arg(matName).arg(cmd - eMI_SelectSubmaterialBase + 1);
  1090. CUndo undo("Rename TrackView node");
  1091. animNode->SetName(newMatName.toUtf8().data());
  1092. animNode->SetSelected(true);
  1093. UpdateNodeRecord(record);
  1094. }
  1095. }
  1096. else if (cmd >= eMI_SetAnimationLayerBase && cmd < eMI_SetAnimationLayerBase + 100)
  1097. {
  1098. if (pNode && pNode->GetNodeType() == eTVNT_Track)
  1099. {
  1100. CTrackViewTrack* pTrack2 = static_cast<CTrackViewTrack*>(pNode);
  1101. pTrack2->SetAnimationLayerIndex(cmd - eMI_SetAnimationLayerBase);
  1102. }
  1103. }
  1104. else if (cmd == eMI_Disable)
  1105. {
  1106. if (pNode)
  1107. {
  1108. CTrackViewSequence* sequence2 = pNode->GetSequence();
  1109. AZ_Assert(nullptr != sequence2, "Expected valid sequence");
  1110. AzToolsFramework::ScopedUndoBatch undoBatch("Node Set Disabled");
  1111. pNode->SetDisabled(!pNode->IsDisabled());
  1112. undoBatch.MarkEntityDirty(sequence2->GetSequenceComponentEntityId());
  1113. }
  1114. }
  1115. else if (cmd == eMI_Mute)
  1116. {
  1117. if (pTrack)
  1118. {
  1119. pTrack->SetMuted(!pTrack->IsMuted());
  1120. }
  1121. }
  1122. else if (cmd == eMI_CustomizeTrackColor)
  1123. {
  1124. CustomizeTrackColor(pTrack);
  1125. }
  1126. else if (cmd == eMI_ClearCustomTrackColor)
  1127. {
  1128. if (pTrack)
  1129. {
  1130. pTrack->ClearCustomColor();
  1131. }
  1132. }
  1133. if (cmd)
  1134. {
  1135. RestoreVerticalScrollPos(scrollPos);
  1136. }
  1137. }
  1138. void CTrackViewNodesCtrl::OnItemDblClick(QTreeWidgetItem* item, int)
  1139. {
  1140. CRecord* record = (CRecord*)item;
  1141. if (record && record->GetNode())
  1142. {
  1143. CTrackViewNode* pNode = record->GetNode();
  1144. if (pNode->GetNodeType() == eTVNT_AnimNode)
  1145. {
  1146. CTrackViewAnimNode* animNode = static_cast<CTrackViewAnimNode*>(pNode);
  1147. if (const AZ::EntityId entityId = animNode->GetAzEntityId();
  1148. entityId.IsValid())
  1149. {
  1150. CUndo undo("Select Object");
  1151. AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
  1152. &AzToolsFramework::ToolsApplicationRequests::SetSelectedEntities,
  1153. AzToolsFramework::EntityIdList{animNode->GetAzEntityId()});
  1154. }
  1155. }
  1156. }
  1157. }
  1158. void CTrackViewNodesCtrl::EditEvents()
  1159. {
  1160. CTVEventsDialog dlg;
  1161. dlg.exec();
  1162. }
  1163. void CTrackViewNodesCtrl::CreateFolder(CTrackViewAnimNode* groupNode)
  1164. {
  1165. // Change Group of the node.
  1166. QString name = QInputDialog::getText(this, tr("Enter Folder Name"), QString());
  1167. if (!name.isEmpty())
  1168. {
  1169. CUndo undo("Create folder");
  1170. if (!groupNode->CreateSubNode(name, AnimNodeType::Group))
  1171. {
  1172. QMessageBox::critical(this, QString(), tr("The name already exists. Use another."));
  1173. }
  1174. }
  1175. }
  1176. struct STrackMenuTreeNode
  1177. {
  1178. QMenu menu;
  1179. CAnimParamType paramType;
  1180. AZStd::map<QString, AZStd::unique_ptr<STrackMenuTreeNode> > children;
  1181. };
  1182. struct SContextMenu
  1183. {
  1184. QMenu main;
  1185. QMenu expandSub;
  1186. QMenu collapseSub;
  1187. QMenu setLayerSub;
  1188. STrackMenuTreeNode addTrackSub;
  1189. QMenu addComponentSub;
  1190. };
  1191. void CTrackViewNodesCtrl::AddGroupNodeAddItems(SContextMenu& contextMenu, CTrackViewAnimNode* animNode)
  1192. {
  1193. contextMenu.main.addAction("Create Folder")->setData(eMI_CreateFolder);
  1194. AzToolsFramework::EntityIdList entityIds;
  1195. AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(
  1196. entityIds, &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
  1197. if (!entityIds.empty())
  1198. {
  1199. const char* msg = entityIds.size() == 1 ? "Add Selected Entity" : "Add Selected Entities";
  1200. contextMenu.main.addAction(msg)->setData(eMI_AddSelectedEntities);
  1201. }
  1202. const bool bIsDirectorOrSequence = (animNode->GetType() == AnimNodeType::Director || animNode->GetNodeType() == eTVNT_Sequence);
  1203. CTrackViewAnimNode* pDirector = bIsDirectorOrSequence ? animNode : animNode->GetDirector();
  1204. if (pDirector->GetAnimNodesByType(AnimNodeType::RadialBlur).GetCount() == 0)
  1205. {
  1206. contextMenu.main.addAction("Add Radial Blur Node")->setData(eMI_AddRadialBlur);
  1207. }
  1208. if (pDirector->GetAnimNodesByType(AnimNodeType::ColorCorrection).GetCount() == 0)
  1209. {
  1210. contextMenu.main.addAction("Add Color Correction Node")->setData(eMI_AddColorCorrection);
  1211. }
  1212. if (pDirector->GetAnimNodesByType(AnimNodeType::DepthOfField).GetCount() == 0)
  1213. {
  1214. contextMenu.main.addAction("Add Depth of Field Node")->setData(eMI_AddDOF);
  1215. }
  1216. if (pDirector->GetAnimNodesByType(AnimNodeType::ScreenFader).GetCount() == 0)
  1217. {
  1218. contextMenu.main.addAction("Add Screen Fader")->setData(eMI_AddScreenfader);
  1219. }
  1220. if (pDirector->GetAnimNodesByType(AnimNodeType::ShadowSetup).GetCount() == 0)
  1221. {
  1222. contextMenu.main.addAction("Add Shadows Setup Node")->setData(eMI_AddShadowSetup);
  1223. }
  1224. // A director node cannot have another director node as a child.
  1225. if (animNode->GetType() != AnimNodeType::Director)
  1226. {
  1227. contextMenu.main.addAction("Add Director(Scene) Node")->setData(eMI_AddDirectorNode);
  1228. }
  1229. contextMenu.main.addAction("Add Comment Node")->setData(eMI_AddCommentNode);
  1230. contextMenu.main.addAction("Add Console Variable Node")->setData(eMI_AddConsoleVariable);
  1231. contextMenu.main.addAction("Add Script Variable Node")->setData(eMI_AddScriptVariable);
  1232. contextMenu.main.addAction("Add Event Node")->setData(eMI_AddEvent);
  1233. }
  1234. void CTrackViewNodesCtrl::AddMenuSeperatorConditional(QMenu& menu, bool& bAppended)
  1235. {
  1236. if (bAppended)
  1237. {
  1238. menu.addSeparator();
  1239. }
  1240. bAppended = false;
  1241. }
  1242. int CTrackViewNodesCtrl::ShowPopupMenuSingleSelection(SContextMenu& contextMenu, CTrackViewSequence* sequence, CTrackViewNode* pNode)
  1243. {
  1244. bool bAppended = false;
  1245. bool isOnComponentNode = false;
  1246. bool isOnAzEntityNode = false;
  1247. const bool bOnSequence = pNode->GetNodeType() == eTVNT_Sequence;
  1248. const bool bOnNode = pNode->GetNodeType() == eTVNT_AnimNode;
  1249. const bool bOnTrack = pNode->GetNodeType() == eTVNT_Track;
  1250. const bool bIsLightAnimationSet = sequence->GetFlags() & IAnimSequence::eSeqFlags_LightAnimationSet;
  1251. // Get track & anim node pointers
  1252. CTrackViewTrack* pTrack = bOnTrack ? static_cast<CTrackViewTrack*>(pNode) : nullptr;
  1253. const bool bOnTrackNotSub = bOnTrack && !pTrack->IsSubTrack();
  1254. if (bOnNode)
  1255. {
  1256. AnimNodeType nodeType = static_cast<CTrackViewAnimNode*>(pNode)->GetType();
  1257. if (nodeType == AnimNodeType::Component)
  1258. {
  1259. isOnComponentNode = true;
  1260. }
  1261. else if (nodeType == AnimNodeType::AzEntity)
  1262. {
  1263. isOnAzEntityNode = true;
  1264. }
  1265. }
  1266. CTrackViewAnimNode* animNode = nullptr;
  1267. if (bOnSequence || bOnNode)
  1268. {
  1269. animNode = static_cast<CTrackViewAnimNode*>(pNode);
  1270. }
  1271. else if (bOnTrack)
  1272. {
  1273. animNode = pTrack->GetAnimNode();
  1274. }
  1275. bool isOnDirector = (animNode && animNode->GetType() == AnimNodeType::Director);
  1276. bool isOnAzEntity = (animNode && animNode->GetType() == AnimNodeType::AzEntity);
  1277. bool isOnSequence = (animNode && animNode->GetNodeType() == eTVNT_Sequence);
  1278. if (isOnSequence)
  1279. {
  1280. contextMenu.main.addAction("Select In Viewport")->setData(eMI_SelectInViewport);
  1281. contextMenu.main.addSeparator();
  1282. }
  1283. // Entity
  1284. if (bOnNode && !bIsLightAnimationSet && animNode->IsBoundToAzEntity())
  1285. {
  1286. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1287. contextMenu.main.addAction("Select In Viewport")->setData(eMI_SelectInViewport);
  1288. bAppended = true;
  1289. }
  1290. {
  1291. bool bCopyPasteRenameAppended = false;
  1292. // Copy & paste nodes
  1293. if ((bOnNode || bOnSequence) && !isOnComponentNode)
  1294. {
  1295. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1296. contextMenu.main.addAction("Copy")->setData(eMI_CopyNodes);
  1297. bCopyPasteRenameAppended = true;
  1298. }
  1299. if (pNode->IsGroupNode() && !isOnAzEntity)
  1300. {
  1301. contextMenu.main.addAction("Paste")->setData(eMI_PasteNodes);
  1302. bCopyPasteRenameAppended = true;
  1303. }
  1304. if ((bOnNode || bOnSequence || bOnTrackNotSub) && !isOnComponentNode)
  1305. {
  1306. contextMenu.main.addAction("Delete")->setData(bOnTrackNotSub ? eMI_RemoveTrack : eMI_RemoveSelected);
  1307. bCopyPasteRenameAppended = true;
  1308. }
  1309. // Renaming
  1310. if (pNode->CanBeRenamed())
  1311. {
  1312. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1313. contextMenu.main.addAction("Rename")->setData(eMI_Rename);
  1314. bCopyPasteRenameAppended = true;
  1315. }
  1316. bAppended = bAppended || bCopyPasteRenameAppended;
  1317. }
  1318. if (bOnTrack)
  1319. {
  1320. // Copy & paste keys
  1321. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1322. contextMenu.main.addAction("Copy Keys")->setData(eMI_CopyKeys);
  1323. contextMenu.main.addAction("Copy Selected Keys")->setData(eMI_CopySelectedKeys);
  1324. contextMenu.main.addAction("Paste Keys")->setData(eMI_PasteKeys);
  1325. bAppended = true;
  1326. }
  1327. // Flags
  1328. {
  1329. bool bFlagAppended = false;
  1330. if (!bOnSequence)
  1331. {
  1332. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1333. QAction* a = contextMenu.main.addAction("Disabled");
  1334. a->setData(eMI_Disable);
  1335. a->setCheckable(true);
  1336. a->setChecked(pNode->IsDisabled());
  1337. // If the node is not currently allowed to be enabled, disable the check box.
  1338. if (pNode->IsDisabled() && !pNode->CanBeEnabled())
  1339. {
  1340. a->setEnabled(false);
  1341. }
  1342. bFlagAppended = true;
  1343. }
  1344. if (bOnTrack)
  1345. {
  1346. if (pTrack->GetParameterType() == AnimParamType::Sound)
  1347. {
  1348. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1349. bool bMuted = pTrack->GetFlags() & IAnimTrack::eAnimTrackFlags_Muted;
  1350. QAction* a = contextMenu.main.addAction("Muted");
  1351. a->setData(eMI_Mute);
  1352. a->setCheckable(true);
  1353. a->setChecked(bMuted);
  1354. bFlagAppended = true;
  1355. }
  1356. }
  1357. // In case that it's a director node instead of a normal group node,
  1358. if (bOnNode && animNode->GetType() == AnimNodeType::Director)
  1359. {
  1360. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1361. QAction* a = contextMenu.main.addAction("Active Director");
  1362. a->setData(eMI_SetAsActiveDirector);
  1363. a->setCheckable(true);
  1364. a->setChecked(animNode->IsActiveDirector());
  1365. bFlagAppended = true;
  1366. }
  1367. bAppended = bAppended || bFlagAppended;
  1368. }
  1369. // Expand / collapse
  1370. if (bOnSequence || pNode->IsGroupNode())
  1371. {
  1372. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1373. contextMenu.expandSub.addAction("Expand all")->setData(eMI_ExpandAll);
  1374. contextMenu.collapseSub.addAction("Collapse all")->setData(eMI_CollapseAll);
  1375. if (!isOnAzEntity)
  1376. {
  1377. contextMenu.expandSub.addAction("Expand Folders")->setData(eMI_ExpandFolders);
  1378. contextMenu.collapseSub.addAction("Collapse Folders")->setData(eMI_CollapseFolders);
  1379. contextMenu.expandSub.addAction("Expand Entities")->setData(eMI_ExpandEntities);
  1380. contextMenu.collapseSub.addAction("Collapse Entities")->setData(eMI_CollapseEntities);
  1381. contextMenu.expandSub.addAction("Expand Events")->setData(eMI_ExpandEvents);
  1382. contextMenu.collapseSub.addAction("Collapse Events")->setData(eMI_CollapseEvents);
  1383. }
  1384. contextMenu.expandSub.setTitle("Expand");
  1385. contextMenu.main.addMenu(&contextMenu.expandSub);
  1386. contextMenu.collapseSub.setTitle("Collapse");
  1387. contextMenu.main.addMenu(&contextMenu.collapseSub);
  1388. bAppended = true;
  1389. }
  1390. // Add/Remove
  1391. {
  1392. if (bOnSequence || (pNode->IsGroupNode() && !isOnAzEntity) )
  1393. {
  1394. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1395. AddGroupNodeAddItems(contextMenu, animNode);
  1396. bAppended = true;
  1397. }
  1398. if (bOnNode)
  1399. {
  1400. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1401. if (!isOnAzEntity)
  1402. {
  1403. // Create 'Add Tracks' submenu
  1404. m_menuParamTypeMap.clear();
  1405. const QString addTracksMenuName = "Add Tracks";
  1406. if (FillAddTrackMenu(contextMenu.addTrackSub, animNode))
  1407. {
  1408. // add script table properties -> tracks available for adding
  1409. unsigned int currentId = 0;
  1410. CreateAddTrackMenuRec(contextMenu.main, addTracksMenuName, animNode, contextMenu.addTrackSub, currentId);
  1411. }
  1412. else
  1413. {
  1414. // no tracks available for adding -> add empty disabled submenu for UI consistency
  1415. contextMenu.main.addMenu(addTracksMenuName)->setEnabled(false);
  1416. }
  1417. }
  1418. bAppended = true;
  1419. }
  1420. }
  1421. bool isLegacySequence = (sequence && sequence->GetSequenceType() == SequenceType::Legacy);
  1422. if (isLegacySequence && bOnNode && !bIsLightAnimationSet && !isOnDirector && !isOnComponentNode && !isOnAzEntityNode)
  1423. {
  1424. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1425. contextMenu.main.addAction("Import FBX File...")->setData(eMI_ImportFromFBX);
  1426. contextMenu.main.addAction("Export FBX File...")->setData(eMI_SaveToFBX);
  1427. bAppended = true;
  1428. }
  1429. // Events
  1430. if (bOnSequence || pNode->IsGroupNode() && !bIsLightAnimationSet && !isOnAzEntity)
  1431. {
  1432. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1433. contextMenu.main.addAction("Edit Events...")->setData(eMI_EditEvents);
  1434. bAppended = true;
  1435. }
  1436. // Delete track menu
  1437. if (bOnTrackNotSub)
  1438. {
  1439. if (pTrack->GetParameterType() == AnimParamType::Animation || pTrack->GetParameterType() == AnimParamType::LookAt || pTrack->GetValueType() == AnimValueType::CharacterAnim)
  1440. {
  1441. // Add the set-animation-layer pop-up menu.
  1442. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1443. CreateSetAnimationLayerPopupMenu(contextMenu.setLayerSub, pTrack);
  1444. contextMenu.setLayerSub.setTitle("Set Animation Layer");
  1445. contextMenu.main.addMenu(&contextMenu.setLayerSub);
  1446. bAppended = true;
  1447. }
  1448. }
  1449. // Track color
  1450. if (bOnTrack)
  1451. {
  1452. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1453. contextMenu.main.addAction("Customize Track Color...")->setData(eMI_CustomizeTrackColor);
  1454. if (pTrack->HasCustomColor())
  1455. {
  1456. contextMenu.main.addAction("Clear Custom Track Color")->setData(eMI_ClearCustomTrackColor);
  1457. }
  1458. bAppended = true;
  1459. }
  1460. // Track hide/unhide flags
  1461. if (bOnNode && !pNode->IsGroupNode())
  1462. {
  1463. AddMenuSeperatorConditional(contextMenu.main, bAppended);
  1464. const QString manageTracksMenuName = "Toggle Tracks";
  1465. auto manageTracksAction = contextMenu.main.addAction(manageTracksMenuName);
  1466. bool bAppendedTrackFlag = false;
  1467. const unsigned int numChildren = animNode->GetChildCount();
  1468. for (unsigned int childIndex = 0; childIndex < numChildren; ++childIndex)
  1469. {
  1470. CTrackViewNode* pChild = animNode->GetChild(childIndex);
  1471. if (pChild->GetNodeType() == eTVNT_Track)
  1472. {
  1473. CTrackViewTrack* pTrack2 = static_cast<CTrackViewTrack*>(pChild);
  1474. if (pTrack2->IsSubTrack())
  1475. {
  1476. continue;
  1477. }
  1478. QAction* a = contextMenu.main.addAction(QString(" %1").arg(pTrack2->GetName().c_str()));
  1479. a->setData(eMI_ShowHideBase + childIndex);
  1480. a->setCheckable(true);
  1481. a->setChecked(!pTrack2->IsHidden());
  1482. bAppendedTrackFlag = true;
  1483. }
  1484. }
  1485. manageTracksAction->setEnabled(bAppendedTrackFlag); // Disable this submenu if no tracks were added.
  1486. bAppended = bAppendedTrackFlag || bAppended;
  1487. }
  1488. return 0;
  1489. }
  1490. int CTrackViewNodesCtrl::ShowPopupMenuMultiSelection(SContextMenu& contextMenu)
  1491. {
  1492. QList<QTreeWidgetItem*> records = ui->treeWidget->selectedItems();
  1493. bool bNodeSelected = false;
  1494. for (int currentNode = 0; currentNode < records.size(); ++currentNode)
  1495. {
  1496. CRecord* pItemInfo = (CRecord*)records[currentNode];
  1497. if (pItemInfo->GetNode()->GetNodeType() == eTVNT_AnimNode)
  1498. {
  1499. bNodeSelected = true;
  1500. }
  1501. }
  1502. if (bNodeSelected)
  1503. {
  1504. contextMenu.main.addAction("Copy Selected Nodes")->setData(eMI_CopySelectedNodes);
  1505. }
  1506. contextMenu.main.addAction("Remove Selected Nodes/Tracks")->setData(eMI_RemoveSelected);
  1507. if (bNodeSelected)
  1508. {
  1509. contextMenu.main.addSeparator();
  1510. contextMenu.main.addAction("Select In Viewport")->setData(eMI_SelectInViewport);
  1511. // Importing FBX is currently only supported on legacy entities. Legacy
  1512. // sequences contain only legacy Cry entities and no AZ component entities.
  1513. CAnimationContext* context = GetIEditor()->GetAnimation();
  1514. AZ_Assert(context, "Expected valid GetIEditor()->GetAnimation()");
  1515. if (context)
  1516. {
  1517. CTrackViewSequence* sequence = context->GetSequence();
  1518. if (sequence && sequence->GetSequenceType() == SequenceType::Legacy)
  1519. {
  1520. contextMenu.main.addAction("Import From FBX File")->setData(eMI_ImportFromFBX);
  1521. contextMenu.main.addAction("Save To FBX File")->setData(eMI_SaveToFBX);
  1522. }
  1523. }
  1524. }
  1525. return 0;
  1526. }
  1527. int CTrackViewNodesCtrl::ShowPopupMenu([[maybe_unused]] QPoint point, const CRecord* record)
  1528. {
  1529. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  1530. if (!sequence)
  1531. {
  1532. return 0;
  1533. }
  1534. SContextMenu contextMenu;
  1535. CTrackViewNode* pNode = record ? record->GetNode() : nullptr;
  1536. if (!pNode)
  1537. {
  1538. return 0;
  1539. }
  1540. if (ui->treeWidget->selectedItems().size() > 1)
  1541. {
  1542. ShowPopupMenuMultiSelection(contextMenu);
  1543. }
  1544. else if (pNode)
  1545. {
  1546. ShowPopupMenuSingleSelection(contextMenu, sequence, pNode);
  1547. }
  1548. if (m_bEditLock)
  1549. {
  1550. SetPopupMenuLock(&contextMenu.main);
  1551. }
  1552. QAction* action = contextMenu.main.exec(QCursor::pos());
  1553. int ret = action ? action->data().toInt() : 0;
  1554. return ret;
  1555. }
  1556. // Add tracks that can be added to the given animation node to the
  1557. // internal track menu tree data structure rooted at menuAddTrack
  1558. bool CTrackViewNodesCtrl::FillAddTrackMenu(STrackMenuTreeNode& menuAddTrack, const CTrackViewAnimNode* animNode)
  1559. {
  1560. bool bTracksToAdd = false;
  1561. const AnimNodeType nodeType = animNode->GetType();
  1562. int paramCount = 0;
  1563. IAnimNode::AnimParamInfos animatableProperties;
  1564. CTrackViewNode* parentNode = animNode->GetParentNode();
  1565. // all AZ::Entity entities are animated through components. Component nodes always have a parent - the containing AZ::Entity
  1566. if (nodeType == AnimNodeType::Component && parentNode)
  1567. {
  1568. // component node - query all the animatable tracks via an EBus request
  1569. // all AnimNodeType::Component are parented to AnimNodeType::AzEntityNodes - get the parent to get it's AZ::EntityId to use for the EBus request
  1570. if (parentNode->GetNodeType() == eTVNT_AnimNode)
  1571. {
  1572. // this cast is safe because we check that the type is eTVNT_AnimNode
  1573. const AZ::EntityId azEntityId = static_cast<CTrackViewAnimNode*>(parentNode)->GetAzEntityId();
  1574. // query the animatable component properties from the Sequence Component
  1575. Maestro::EditorSequenceComponentRequestBus::Event(const_cast<CTrackViewAnimNode*>(animNode)->GetSequence()->GetSequenceComponentEntityId(),
  1576. &Maestro::EditorSequenceComponentRequestBus::Events::GetAllAnimatablePropertiesForComponent,
  1577. animatableProperties, azEntityId, animNode->GetComponentId());
  1578. paramCount = static_cast<int>(animatableProperties.size());
  1579. }
  1580. }
  1581. else
  1582. {
  1583. // legacy Entity
  1584. paramCount = animNode->GetParamCount();
  1585. }
  1586. for (int i = 0; i < paramCount; ++i)
  1587. {
  1588. CAnimParamType paramType;
  1589. QString name;
  1590. // get the animatable param name
  1591. if (nodeType == AnimNodeType::Component)
  1592. {
  1593. // Skip over any hidden params
  1594. if (animatableProperties[i].flags & IAnimNode::ESupportedParamFlags::eSupportedParamFlags_Hidden)
  1595. {
  1596. continue;
  1597. }
  1598. paramType = animatableProperties[i].paramType;
  1599. }
  1600. else
  1601. {
  1602. // legacy node
  1603. paramType = animNode->GetParamType(i);
  1604. if (paramType == AnimParamType::Invalid)
  1605. {
  1606. continue;
  1607. }
  1608. IAnimNode::ESupportedParamFlags paramFlags = animNode->GetParamFlags(paramType);
  1609. CTrackViewTrack* pTrack = animNode->GetTrackForParameter(paramType);
  1610. if (pTrack && !(paramFlags & IAnimNode::eSupportedParamFlags_MultipleTracks))
  1611. {
  1612. continue;
  1613. }
  1614. }
  1615. name = QString::fromUtf8(animNode->GetParamName(paramType).c_str());
  1616. QStringList splitName = name.split("/", Qt::SkipEmptyParts);
  1617. STrackMenuTreeNode* pCurrentNode = &menuAddTrack;
  1618. for (const QString& segment : splitName)
  1619. {
  1620. auto findIter = pCurrentNode->children.find(segment);
  1621. if (findIter != pCurrentNode->children.end())
  1622. {
  1623. pCurrentNode = findIter->second.get();
  1624. }
  1625. //else {} - keep current node to avoid unnecessary nesting
  1626. }
  1627. // only add tracks to the that STrackMenuTreeNode tree that haven't already been added
  1628. CTrackViewTrackBundle matchedTracks = animNode->GetTracksByParam(paramType);
  1629. if (matchedTracks.GetCount() == 0 && !splitName.isEmpty())
  1630. {
  1631. STrackMenuTreeNode* pParamNode = new STrackMenuTreeNode;
  1632. pCurrentNode->children[splitName.back()] = AZStd::unique_ptr<STrackMenuTreeNode>(pParamNode);
  1633. pParamNode->paramType = paramType;
  1634. bTracksToAdd = true;
  1635. }
  1636. }
  1637. return bTracksToAdd;
  1638. }
  1639. //
  1640. // FillAddTrackMenu fills the data structure for tracks to add (a STrackMenuTreeNode tree)
  1641. // CreateAddTrackMenuRec actually creates the Qt submenu from this data structure
  1642. //
  1643. void CTrackViewNodesCtrl::CreateAddTrackMenuRec(QMenu& parent, const QString& name, CTrackViewAnimNode* animNode, struct STrackMenuTreeNode& node, unsigned int& currentId)
  1644. {
  1645. if (node.paramType.GetType() == AnimParamType::Invalid)
  1646. {
  1647. node.menu.setTitle(name);
  1648. parent.addMenu(&node.menu);
  1649. for (auto iter = node.children.begin(); iter != node.children.end(); ++iter)
  1650. {
  1651. CreateAddTrackMenuRec(node.menu, iter->first, animNode, *iter->second.get(), currentId);
  1652. }
  1653. }
  1654. else
  1655. {
  1656. m_menuParamTypeMap[currentId] = node.paramType;
  1657. QVariant paramTypeMenuID;
  1658. paramTypeMenuID.setValue(eMI_AddTrackBase + currentId);
  1659. parent.addAction(name)->setData(paramTypeMenuID);
  1660. ++currentId;
  1661. }
  1662. }
  1663. void CTrackViewNodesCtrl::SetPopupMenuLock(QMenu* menu)
  1664. {
  1665. if (!m_bEditLock || !menu)
  1666. {
  1667. return;
  1668. }
  1669. UINT count = menu->actions().size();
  1670. for (UINT i = 0; i < count; ++i)
  1671. {
  1672. QAction* a = menu->actions()[i];
  1673. QString menuString = a->text();
  1674. if (menuString != "Expand" && menuString != "Collapse")
  1675. {
  1676. a->setEnabled(false);
  1677. }
  1678. }
  1679. }
  1680. float CTrackViewNodesCtrl::SaveVerticalScrollPos() const
  1681. {
  1682. int sbMin = ui->treeWidget->verticalScrollBar()->minimum();
  1683. int sbMax = ui->treeWidget->verticalScrollBar()->maximum();
  1684. return float(ui->treeWidget->verticalScrollBar()->value() - sbMin) / AZStd::max(float(sbMax - sbMin), 1.0f);
  1685. }
  1686. void CTrackViewNodesCtrl::RestoreVerticalScrollPos(float fScrollPos)
  1687. {
  1688. int sbMin = ui->treeWidget->verticalScrollBar()->minimum();
  1689. int sbMax = ui->treeWidget->verticalScrollBar()->maximum();
  1690. int newScrollPos = qRound(fScrollPos * (sbMax - sbMin)) + sbMin;
  1691. ui->treeWidget->verticalScrollBar()->setValue(newScrollPos);
  1692. }
  1693. void CTrackViewNodesCtrl::FillAutoCompletionListForFilter()
  1694. {
  1695. QStringList strings;
  1696. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  1697. if (sequence)
  1698. {
  1699. ui->noitems->hide();
  1700. ui->treeWidget->show();
  1701. ui->searchField->show();
  1702. ui->searchCount->show();
  1703. CTrackViewAnimNodeBundle animNodes = sequence->GetAllAnimNodes();
  1704. const unsigned int animNodeCount = animNodes.GetCount();
  1705. for (unsigned int i = 0; i < animNodeCount; ++i)
  1706. {
  1707. strings << QString::fromUtf8(animNodes.GetNode(i)->GetName().c_str());
  1708. }
  1709. }
  1710. else
  1711. {
  1712. ui->noitems->show();
  1713. ui->treeWidget->hide();
  1714. ui->searchField->hide();
  1715. ui->searchCount->hide();
  1716. }
  1717. QCompleter* c = new QCompleter(strings, this);
  1718. c->setCaseSensitivity(Qt::CaseInsensitive);
  1719. c->setCompletionMode(QCompleter::InlineCompletion);
  1720. ui->searchField->setCompleter(c);
  1721. }
  1722. void CTrackViewNodesCtrl::OnFilterChange(const QString& text)
  1723. {
  1724. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  1725. if (sequence)
  1726. {
  1727. m_currentMatchIndex = 0; // Reset the match index
  1728. m_matchCount = 0; // and the count.
  1729. if (!text.isEmpty())
  1730. {
  1731. QList<QTreeWidgetItem*> items = ui->treeWidget->findItems(text, Qt::MatchContains | Qt::MatchRecursive);
  1732. CTrackViewAnimNodeBundle animNodes = sequence->GetAllAnimNodes();
  1733. m_matchCount = items.size(); // and the count.
  1734. if (!items.empty())
  1735. {
  1736. ui->treeWidget->selectionModel()->clear();
  1737. items.front()->setSelected(true);
  1738. }
  1739. }
  1740. QString matchCountText = QString("%1/%2").arg(m_matchCount == 0 ? 0 : 1).arg(m_matchCount); // One-based indexing
  1741. ui->searchCount->setText(matchCountText);
  1742. }
  1743. }
  1744. int CTrackViewNodesCtrl::GetMatNameAndSubMtlIndexFromName(QString& matName, const char* nodeName)
  1745. {
  1746. if (const char* pCh = strstr(nodeName, ".["))
  1747. {
  1748. char matPath[MAX_PATH];
  1749. azstrncpy(matPath, AZ_ARRAY_SIZE(matPath), nodeName, (size_t)(pCh - nodeName));
  1750. matName = matPath;
  1751. pCh += 2;
  1752. if ((*pCh) != 0)
  1753. {
  1754. const int index = atoi(pCh) - 1;
  1755. return index;
  1756. }
  1757. }
  1758. else
  1759. {
  1760. matName = nodeName;
  1761. }
  1762. return -1;
  1763. }
  1764. void CTrackViewNodesCtrl::ShowNextResult()
  1765. {
  1766. if (m_matchCount > 1)
  1767. {
  1768. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  1769. if (sequence && !ui->searchField->text().isEmpty())
  1770. {
  1771. QList<QTreeWidgetItem*> items = ui->treeWidget->findItems(ui->searchField->text(), Qt::MatchContains | Qt::MatchRecursive);
  1772. CTrackViewAnimNodeBundle animNodes = sequence->GetAllAnimNodes();
  1773. m_matchCount = items.size(); // and the count.
  1774. if (!items.empty())
  1775. {
  1776. ++m_currentMatchIndex;
  1777. m_currentMatchIndex = m_currentMatchIndex % m_matchCount;
  1778. ui->treeWidget->selectionModel()->clear();
  1779. items[m_currentMatchIndex]->setSelected(true);
  1780. }
  1781. QString matchCountText = QString("%1/%2").arg(m_currentMatchIndex + 1).arg(m_matchCount); // One-based indexing
  1782. ui->searchCount->setText(matchCountText);
  1783. }
  1784. }
  1785. }
  1786. void CTrackViewNodesCtrl::Update()
  1787. {
  1788. // Update the Track UI elements with the latest names of the Tracks.
  1789. // In some cases the Track names (param names) may not be available at the time
  1790. // of the Sequence activation because they come from the animated entities (which may not be active).
  1791. // So just update them once a frame to make sure they are the latest.
  1792. for (auto iter = m_nodeToRecordMap.begin(); iter != m_nodeToRecordMap.end(); ++iter)
  1793. {
  1794. const CTrackViewNode* node = iter->first;
  1795. CTrackViewNodesCtrl::CRecord* record = iter->second;
  1796. if (node && record)
  1797. {
  1798. if (node->GetNodeType() == eTVNT_Track)
  1799. {
  1800. const CTrackViewAnimNode* track = static_cast<const CTrackViewAnimNode*>(node);
  1801. if (track)
  1802. {
  1803. record->setText(0, QString::fromUtf8(track->GetName().c_str()));
  1804. }
  1805. }
  1806. }
  1807. }
  1808. }
  1809. void CTrackViewNodesCtrl::keyPressEvent(QKeyEvent* event)
  1810. {
  1811. // HAVE TO INCLUDE CASES FOR THESE IN THE ShortcutOverride handler in ::event() below
  1812. switch (event->key())
  1813. {
  1814. case Qt::Key_Z:
  1815. if (event->modifiers() == Qt::ControlModifier)
  1816. {
  1817. GetIEditor()->Undo();
  1818. event->accept();
  1819. }
  1820. break;
  1821. default:
  1822. break;
  1823. }
  1824. }
  1825. bool CTrackViewNodesCtrl::event(QEvent* e)
  1826. {
  1827. if (e->type() == QEvent::ShortcutOverride)
  1828. {
  1829. // since we respond to the following things, let Qt know so that shortcuts don't override us
  1830. bool respondsToEvent = false;
  1831. QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
  1832. if (keyEvent->key() == Qt::Key_Z && keyEvent->modifiers() == Qt::ControlModifier)
  1833. {
  1834. respondsToEvent = true;
  1835. }
  1836. if (respondsToEvent)
  1837. {
  1838. e->accept();
  1839. return true;
  1840. }
  1841. }
  1842. return QWidget::event(e);
  1843. }
  1844. void CTrackViewNodesCtrl::CreateSetAnimationLayerPopupMenu(QMenu& menuSetLayer, CTrackViewTrack* pTrack) const
  1845. {
  1846. // First collect layers already in use.
  1847. AZStd::vector<int> layersInUse;
  1848. CTrackViewTrackBundle lookAtTracks = pTrack->GetAnimNode()->GetTracksByParam(AnimParamType::LookAt);
  1849. const auto numLookAtTracks = lookAtTracks.GetCount();
  1850. AZ_Assert(numLookAtTracks <= 1, "Invalid number of LookAt tracks %u", numLookAtTracks);
  1851. if (numLookAtTracks > 0)
  1852. {
  1853. const int kDefaultLookIKLayer = 15;
  1854. int lookIKLayerIndex = lookAtTracks.GetTrack(0)->GetAnimationLayerIndex();
  1855. if (lookIKLayerIndex < 0) // Not set before, use the default instead.
  1856. {
  1857. lookIKLayerIndex = kDefaultLookIKLayer;
  1858. }
  1859. layersInUse.push_back(lookIKLayerIndex);
  1860. }
  1861. CTrackViewTrackBundle animationTracks = pTrack->GetAnimNode()->GetTracksByParam(AnimParamType::Animation);
  1862. const unsigned int numAnimationTracks = animationTracks.GetCount();
  1863. for (unsigned int i = 0; i < numAnimationTracks; ++i)
  1864. {
  1865. CTrackViewTrack* pAnimationTrack = animationTracks.GetTrack(i);
  1866. if (pAnimationTrack)
  1867. {
  1868. const int kAdditiveLayerOffset = 6;
  1869. int layerIndex = pAnimationTrack->GetAnimationLayerIndex();
  1870. if (layerIndex < 0) // Not set before, use the default instead.
  1871. {
  1872. layerIndex = i == 0 ? 0 : kAdditiveLayerOffset + i;
  1873. }
  1874. layersInUse.push_back(layerIndex);
  1875. }
  1876. }
  1877. // Add layer items.
  1878. for (int i = 0; i < 16; ++i)
  1879. {
  1880. QString layerText = QString("Layer #%1").arg(i);
  1881. QAction* a = menuSetLayer.addAction(layerText);
  1882. a->setData(eMI_SetAnimationLayerBase + i);
  1883. a->setCheckable(true);
  1884. a->setChecked(pTrack->GetAnimationLayerIndex() == i);
  1885. a->setEnabled(!stl::find(layersInUse, i));
  1886. }
  1887. }
  1888. void CTrackViewNodesCtrl::CustomizeTrackColor(CTrackViewTrack* pTrack)
  1889. {
  1890. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  1891. if (!sequence)
  1892. {
  1893. return;
  1894. }
  1895. AZ::Color defaultColor;
  1896. if (pTrack->HasCustomColor())
  1897. {
  1898. ColorB customColor = pTrack->GetCustomColor();
  1899. defaultColor = AZ::Color(customColor.r, customColor.g, customColor.b, customColor.a);
  1900. }
  1901. const AZ::Color color = AzQtComponents::ColorPicker::getColor(AzQtComponents::ColorPicker::Configuration::RGB, defaultColor, tr("Select Color"));
  1902. if (color != defaultColor)
  1903. {
  1904. AzToolsFramework::ScopedUndoBatch undoBatch("Customize Track Color");
  1905. pTrack->SetCustomColor(ColorB(color.GetR8(), color.GetG8(), color.GetB8()));
  1906. undoBatch.MarkEntityDirty(sequence->GetSequenceComponentEntityId());
  1907. UpdateDopeSheet();
  1908. }
  1909. }
  1910. void CTrackViewNodesCtrl::ClearCustomTrackColor(CTrackViewTrack* pTrack)
  1911. {
  1912. CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
  1913. if (!sequence)
  1914. {
  1915. return;
  1916. }
  1917. AzToolsFramework::ScopedUndoBatch undoBatch("Clear Custom Track Color");
  1918. pTrack->ClearCustomColor();
  1919. undoBatch.MarkEntityDirty(sequence->GetSequenceComponentEntityId());
  1920. UpdateDopeSheet();
  1921. }
  1922. void CTrackViewNodesCtrl::paintEvent(QPaintEvent* event)
  1923. {
  1924. QWidget::paintEvent(event);
  1925. UpdateDopeSheet();
  1926. }
  1927. CTrackViewNodesCtrl::CRecord* CTrackViewNodesCtrl::GetNodeRecord(const CTrackViewNode* pNode) const
  1928. {
  1929. auto findIter = m_nodeToRecordMap.find(pNode);
  1930. if (findIter == m_nodeToRecordMap.end())
  1931. {
  1932. return nullptr;
  1933. }
  1934. AZ_Assert(findIter->second->GetNode() == pNode, "Node record does not belong to the node %p", pNode);
  1935. return findIter->second;
  1936. }
  1937. void CTrackViewNodesCtrl::UpdateDopeSheet()
  1938. {
  1939. UpdateRecordVisibility();
  1940. if (m_pDopeSheet)
  1941. {
  1942. m_pDopeSheet->update();
  1943. }
  1944. }
  1945. // Workaround: CXTPReportRecord::IsVisible is
  1946. // unreliable after the last visible element
  1947. void CTrackViewNodesCtrl::UpdateRecordVisibility()
  1948. {
  1949. // Mark all records invisible
  1950. for (auto iter = m_nodeToRecordMap.begin(); iter != m_nodeToRecordMap.end(); ++iter)
  1951. {
  1952. iter->second->m_bVisible = ui->treeWidget->visualItemRect(iter->second).isValid();
  1953. }
  1954. }
  1955. void CTrackViewNodesCtrl::OnNodeChanged(CTrackViewNode* pNode, ITrackViewSequenceListener::ENodeChangeType type)
  1956. {
  1957. if (pNode->GetSequence() != GetIEditor()->GetAnimation()->GetSequence())
  1958. {
  1959. return;
  1960. }
  1961. if (!m_bIgnoreNotifications)
  1962. {
  1963. CTrackViewNode* pParentNode = pNode->GetParentNode();
  1964. CRecord* pNodeRecord = GetNodeRecord(pNode);
  1965. CRecord* pParentNodeRecord = pParentNode ? GetNodeRecord(pParentNode) : nullptr;
  1966. float storedScrollPosition = SaveVerticalScrollPos();
  1967. switch (type)
  1968. {
  1969. case ITrackViewSequenceListener::eNodeChangeType_Added:
  1970. case ITrackViewSequenceListener::eNodeChangeType_Unhidden:
  1971. if (pParentNodeRecord)
  1972. {
  1973. AddNodeRecord(pParentNodeRecord, pNode);
  1974. }
  1975. break;
  1976. case ITrackViewSequenceListener::eNodeChangeType_Removed:
  1977. case ITrackViewSequenceListener::eNodeChangeType_Hidden:
  1978. if (pNodeRecord)
  1979. {
  1980. EraseNodeRecordRec(pNode);
  1981. delete pNodeRecord;
  1982. }
  1983. break;
  1984. case ITrackViewSequenceListener::eNodeChangeType_Expanded:
  1985. if (pNodeRecord)
  1986. {
  1987. pNodeRecord->setExpanded(true);
  1988. }
  1989. break;
  1990. case ITrackViewSequenceListener::eNodeChangeType_Collapsed:
  1991. if (pNodeRecord)
  1992. {
  1993. pNodeRecord->setExpanded(false);
  1994. }
  1995. break;
  1996. case ITrackViewSequenceListener::eNodeChangeType_Disabled:
  1997. case ITrackViewSequenceListener::eNodeChangeType_Enabled:
  1998. case ITrackViewSequenceListener::eNodeChangeType_Muted:
  1999. case ITrackViewSequenceListener::eNodeChangeType_Unmuted:
  2000. case ITrackViewSequenceListener::eNodeChangeType_NodeOwnerChanged:
  2001. if (pNodeRecord)
  2002. {
  2003. UpdateNodeRecord(pNodeRecord);
  2004. }
  2005. }
  2006. switch (type)
  2007. {
  2008. case ITrackViewSequenceListener::eNodeChangeType_Added:
  2009. case ITrackViewSequenceListener::eNodeChangeType_Unhidden:
  2010. case ITrackViewSequenceListener::eNodeChangeType_Removed:
  2011. case ITrackViewSequenceListener::eNodeChangeType_Hidden:
  2012. case ITrackViewSequenceListener::eNodeChangeType_Expanded:
  2013. case ITrackViewSequenceListener::eNodeChangeType_Collapsed:
  2014. update();
  2015. RestoreVerticalScrollPos(storedScrollPosition);
  2016. break;
  2017. case eNodeChangeType_SetAsActiveDirector:
  2018. update();
  2019. break;
  2020. }
  2021. }
  2022. else
  2023. {
  2024. m_bNeedReload = true;
  2025. }
  2026. }
  2027. void CTrackViewNodesCtrl::OnNodeRenamed(CTrackViewNode* pNode, [[maybe_unused]] const char* pOldName)
  2028. {
  2029. if (!m_bIgnoreNotifications)
  2030. {
  2031. CRecord* pNodeRecord = GetNodeRecord(pNode);
  2032. pNodeRecord->setText(0, QString::fromUtf8(pNode->GetName().c_str()));
  2033. update();
  2034. }
  2035. else
  2036. {
  2037. m_bNeedReload = true;
  2038. }
  2039. }
  2040. void CTrackViewNodesCtrl::BeginUndoTransaction()
  2041. {
  2042. m_bNeedReload = false;
  2043. m_bIgnoreNotifications = true;
  2044. m_storedScrollPosition = SaveVerticalScrollPos();
  2045. }
  2046. void CTrackViewNodesCtrl::EndUndoTransaction()
  2047. {
  2048. m_bIgnoreNotifications = false;
  2049. if (m_bNeedReload)
  2050. {
  2051. Reload();
  2052. RestoreVerticalScrollPos(m_storedScrollPosition);
  2053. m_bNeedReload = false;
  2054. }
  2055. UpdateDopeSheet();
  2056. }
  2057. QIcon CTrackViewNodesCtrl::TrackViewIcon(const CTrackViewTrack* pTrack)
  2058. {
  2059. const QIcon defaultIcon(QStringLiteral(":/nodes/tvnodes-13.png"));
  2060. if (!pTrack)
  2061. {
  2062. return defaultIcon;
  2063. }
  2064. const CAnimParamType paramType = pTrack->GetParameterType();
  2065. const AnimValueType valueType = pTrack->GetValueType();
  2066. const AnimNodeType nodeType = pTrack->GetAnimNode()->GetType();
  2067. if (nodeType == AnimNodeType::RadialBlur || nodeType == AnimNodeType::ColorCorrection || nodeType == AnimNodeType::DepthOfField ||
  2068. nodeType == AnimNodeType::ShadowSetup)
  2069. {
  2070. return defaultIcon;
  2071. }
  2072. switch (valueType)
  2073. {
  2074. case AnimValueType::CharacterAnim:
  2075. case AnimValueType::AssetBlend:
  2076. return QIcon(QStringLiteral(":/nodes/tvnodes-10.png"));
  2077. }
  2078. AnimParamType type = paramType.GetType();
  2079. switch (type)
  2080. {
  2081. case AnimParamType::Position:
  2082. return QIcon(QStringLiteral(":/nodes/tvnodes-03.png"));
  2083. case AnimParamType::Rotation:
  2084. return QIcon(QStringLiteral(":/nodes/tvnodes-04.png"));
  2085. case AnimParamType::Scale:
  2086. return QIcon(QStringLiteral(":/nodes/tvnodes-05.png"));
  2087. case AnimParamType::Event:
  2088. case AnimParamType::TrackEvent:
  2089. return QIcon(QStringLiteral(":/nodes/tvnodes-06.png"));
  2090. case AnimParamType::Visibility:
  2091. return QIcon(QStringLiteral(":/nodes/tvnodes-07.png"));
  2092. case AnimParamType::Camera:
  2093. return QIcon(QStringLiteral(":/nodes/tvnodes-08.png"));
  2094. case AnimParamType::Sound:
  2095. return QIcon(QStringLiteral(":/nodes/tvnodes-09.png"));
  2096. case AnimParamType::Animation:
  2097. case AnimParamType::TimeRanges:
  2098. return QIcon(QStringLiteral(":/nodes/tvnodes-10.png"));
  2099. case AnimParamType::Sequence:
  2100. return QIcon(QStringLiteral(":/nodes/tvnodes-11.png"));
  2101. case AnimParamType::Capture:
  2102. return QIcon(QStringLiteral(":/nodes/tvnodes-25.png"));
  2103. case AnimParamType::Console:
  2104. return QIcon(QStringLiteral(":/nodes/tvnodes-15.png"));
  2105. case AnimParamType::LookAt:
  2106. return QIcon(QStringLiteral(":/nodes/tvnodes-17.png"));
  2107. case AnimParamType::TimeWarp:
  2108. return QIcon(QStringLiteral(":/nodes/tvnodes-22.png"));
  2109. case AnimParamType::CommentText:
  2110. return QIcon(QStringLiteral(":/nodes/tvnodes-23.png"));
  2111. case AnimParamType::ShakeMultiplier:
  2112. [[fallthrough]];
  2113. case AnimParamType::TransformNoise:
  2114. return QIcon(QStringLiteral(":/nodes/tvnodes-28.png"));
  2115. default:
  2116. case AnimParamType::Float:
  2117. break;
  2118. }
  2119. return defaultIcon;
  2120. }
  2121. QIcon CTrackViewNodesCtrl::TrackViewNodeIcon(AnimNodeType type)
  2122. {
  2123. switch (type)
  2124. {
  2125. case AnimNodeType::AzEntity:
  2126. return QIcon(QStringLiteral(":/nodes/tvnodes-29.png"));
  2127. case AnimNodeType::Director:
  2128. return QIcon(QStringLiteral(":/nodes/tvnodes-27.png"));
  2129. case AnimNodeType::CVar:
  2130. return QIcon(QStringLiteral(":/nodes/tvnodes-15.png"));
  2131. case AnimNodeType::ScriptVar:
  2132. return QIcon(QStringLiteral(":/nodes/tvnodes-14.png"));
  2133. case AnimNodeType::Material:
  2134. return QIcon(QStringLiteral(":/nodes/tvnodes-16.png"));
  2135. case AnimNodeType::Event:
  2136. return QIcon(QStringLiteral(":/nodes/tvnodes-06.png"));
  2137. case AnimNodeType::Group:
  2138. return QIcon(QStringLiteral(":/nodes/tvnodes-01.png"));
  2139. case AnimNodeType::Layer:
  2140. return QIcon(QStringLiteral(":/nodes/tvnodes-20.png"));
  2141. case AnimNodeType::Comment:
  2142. return QIcon(QStringLiteral(":/nodes/tvnodes-23.png"));
  2143. case AnimNodeType::Light:
  2144. return QIcon(QStringLiteral(":/nodes/tvnodes-18.png"));
  2145. case AnimNodeType::ShadowSetup:
  2146. return QIcon(QStringLiteral(":/nodes/tvnodes-24.png"));
  2147. }
  2148. return QIcon(QStringLiteral(":/nodes/tvnodes-21.png"));
  2149. }
  2150. QIcon CTrackViewNodesCtrl::GetIconForTrack(const CTrackViewTrack* pTrack)
  2151. {
  2152. return TrackViewIcon(pTrack);
  2153. }
  2154. void CTrackViewNodesCtrl::OnKeysChanged(CTrackViewSequence* sequence)
  2155. {
  2156. if (!m_bIgnoreNotifications && sequence && sequence == GetIEditor()->GetAnimation()->GetSequence())
  2157. {
  2158. UpdateDopeSheet();
  2159. }
  2160. }
  2161. void CTrackViewNodesCtrl::OnKeySelectionChanged(CTrackViewSequence* sequence)
  2162. {
  2163. OnKeysChanged(sequence);
  2164. }
  2165. void CTrackViewNodesCtrl::OnNodeSelectionChanged(CTrackViewSequence* sequence)
  2166. {
  2167. if (m_bSelectionChanging)
  2168. {
  2169. return;
  2170. }
  2171. if (!m_bIgnoreNotifications && sequence && sequence == GetIEditor()->GetAnimation()->GetSequence())
  2172. {
  2173. UpdateDopeSheet();
  2174. CTrackViewAnimNodeBundle animNodes = sequence->GetAllAnimNodes();
  2175. const uint numNodes = animNodes.GetCount();
  2176. for (uint i = 0; i < numNodes; ++i)
  2177. {
  2178. CTrackViewAnimNode* pNode = animNodes.GetNode(i);
  2179. if (pNode->IsSelected())
  2180. {
  2181. SelectRow(pNode, false, false);
  2182. }
  2183. else
  2184. {
  2185. DeselectRow(pNode);
  2186. }
  2187. }
  2188. }
  2189. }
  2190. void CTrackViewNodesCtrl::SelectRow(CTrackViewNode* pNode, const bool bEnsureVisible, const bool bDeselectOtherRows)
  2191. {
  2192. AZStd::unordered_map<const CTrackViewNode*, CRecord*>::const_iterator it = m_nodeToRecordMap.find(pNode);
  2193. if (it != m_nodeToRecordMap.end())
  2194. {
  2195. if (bDeselectOtherRows)
  2196. {
  2197. ui->treeWidget->selectionModel()->clear();
  2198. }
  2199. (*it).second->setSelected(true);
  2200. if (bEnsureVisible)
  2201. {
  2202. ui->treeWidget->scrollToItem((*it).second);
  2203. }
  2204. }
  2205. }
  2206. void CTrackViewNodesCtrl::DeselectRow(CTrackViewNode* pNode)
  2207. {
  2208. AZStd::unordered_map<const CTrackViewNode*, CRecord*>::const_iterator it = m_nodeToRecordMap.find(pNode);
  2209. if (it != m_nodeToRecordMap.end())
  2210. {
  2211. (*it).second->setSelected(false);
  2212. }
  2213. }
  2214. void CTrackViewNodesCtrl::EraseNodeRecordRec(CTrackViewNode* pNode)
  2215. {
  2216. m_nodeToRecordMap.erase(pNode);
  2217. const unsigned int numChildren = pNode->GetChildCount();
  2218. for (unsigned int i = 0; i < numChildren; ++i)
  2219. {
  2220. EraseNodeRecordRec(pNode->GetChild(i));
  2221. }
  2222. }
  2223. #include <TrackView/moc_TrackViewNodes.cpp>