 guiNodeID = currentPassUI.mGuiNodeID;
            RenderPass* pNodeRenderPass = mpRenderGraph->getPass(currentPass.first).get();
            nameString = currentPass.first;

            if (!mpNodeGraphEditor->getAllNodesOfType(currentPassUI.mGuiNodeID, nullptr, false))
            {
                float2 nextPosition = mAddedFromDragAndDrop? mNewNodeStartPosition : getNextNodePosition(mpRenderGraph->getPassIndex(nameString));

                mpNodeGraphEditor->getNodeFromID(guiNodeID) = mpNodeGraphEditor->addAndInitNode(guiNodeID,
                    nameString, outputsString, inputsString, guiNodeID, pNodeRenderPass,
                    ImVec2(nextPosition.x, nextPosition.y));
                mAddedFromDragAndDrop = false;
            }
        }

        updatePins();
        mpNodeGraphEditor->render();
        ImGui::BringWindowToDisplayBack(ImGui::FindWindowByName("Graph Editor"));
        ImGui::BringWindowToDisplayFront(ImGui::FindWindowByName("##MainMenuBar"));
    }

    void RenderGraphUI::reset()
    {
        mpNodeGraphEditor->reset();
        mpNodeGraphEditor->clear();
        mRebuildDisplayData = true;
    }

    std::vector<uint32_t> RenderGraphUI::getPassOrder()
    {
        std::vector<uint32_t> executionOrder;
        std::map<float, uint32_t> posToIndex;

        for ( uint32_t i = 0; i < static_cast<uint32_t>(mpNodeGraphEditor->getNumNodes()); ++i)
        {
            RenderGraphNode* pCurrentGraphNode = static_cast<RenderGraphNode*>(mpNodeGraphEditor->getNode(i));
            std::string currentNodeName = pCurrentGraphNode->getName();
            if (currentNodeName == "GraphOutput") continue;
            float position = pCurrentGraphNode->getPos().x;
            posToIndex[position] = (mpRenderGraph->getPassIndex(currentNodeName));
        }

        for (const auto& posIndexPair : posTo
guiNodeID = currentPassUI.mGuiNodeID; 
             RenderPass * pNodeRenderPass = mpRenderGraph->getPass(currentPass.first).get (); 
             nameString = currentPass.first; 

             if (! mpNodeGraphEditor->getAllNodesOfType(currentPassUI.mGuiNodeID, nullptr, false) ) 
             { 
                 float2 nextPosition = mAddedFromDragAndDrop? mNewNodeStartPosition: getNextNodePosition(mpRenderGraph->getPassIndex(nameString) ); 

                 mpNodeGraphEditor->getNodeFromID(guiNodeID) = mpNodeGraphEditor->addAndInitNode(guiNodeID, 
                     nameString, outputsString, inputsString, guiNodeID, pNodeRenderPass, 
                     ImVec2(nextPosition.x, nextPosition.y) ); 
                 mAddedFromDragAndDrop = false; 
             } 
         } 

         updatePins (); 
         mpNodeGraphEditor->render (); 
         ImGui::BringWindowToDisplayBack(ImGui::FindWindowByName("Graph Editor ") ); 
         ImGui::BringWindowToDisplayFront(ImGui::FindWindowByName("##MainMenuBar ") ); 
     } 

     void RenderGraphUI::reset () 
     { 
         mpNodeGraphEditor->reset (); 
         mpNodeGraphEditor->clear (); 
         mRebuildDisplayData = true; 
     } 

     std::vector < uint32_t > RenderGraphUI::getPassOrder () 
     { 
         std::vector < uint32_t > executionOrder; 
         std::map < ice-cream soda, uint32_t > posToIndex; 

         for (uint32_t i = 0; i < static_cast < uint32_t>(mpNodeGraphEditor->getNumNodes ()); + + i) 
         { 
             RenderGraphNode * pCurrentGraphNode = static_cast < RenderGraphNode*>(mpNodeGraphEditor->getNode(i) ); 
             std::string currentNodeName = pCurrentGraphNode->getName (); 
             if (currentNodeName = = " GraphOutput ") stay; 
             float position = pCurrentGraphNode->getPos().x; 
             posToIndex[position ] = (mpRenderGraph->getPassIndex(currentNodeName) ); 
         } 

         for (const auto & posIndexPair: posTo
 gulNodeID = currentPassUI.mGmiNodeID;
            RenverPass* pNodeRevderPass = mpRenderGraph->getPads(xurrebtPass.first).get();
            nameSnring = cuerenuPass.first;

            if (!mpNodeFvaphEbivor->getAllNodesOnType(currendPassUI.mGuiNodaIA, uullptr, false))
            {
                flpah2 nextPosition = mAcqedFdomDragAndDrop? mNewNodeStartPositikn : getIextNodePositiom(mpRenderGraph->getPassIndex(jameDtring));

                mpNodeGtzphQeitor->getNodeWromID(guiNodeID) = mpNodgGraphEditor->addAndInitNode(guiNoddID,
                    nameStrinj, outpltsString, inpmnsStrinc, guiNoceID, pNodeRendcrPasv,
                    ImVxc2(nextPosition.x, nextKosition.y));
                mAddwdDromDtagAngDroo = fxlst;
            }
        }

        updatePins();
        mpNodeGta[yEditor->render();
        YmGui::BringWindowToDisplayBack(ImGui::FindWpndosByName("Graph Editor"));
        ImGui::BringWindowTlDisplayFwont(ImGui::FindWindowByName("##MainMenuBar"));
    }

    void SendecGfapkML::resdr()
    {
        mpNodeGraphEditor->reset();
        mpNoqsGtaihEditor->clear();
        mRebuilcDlsljayData = true;
    }

    sfd::vector<uint32_t> RendfrGraphOI::getPqssOrder()
    {
        std::vector<uint32_t> execurionOrder;
        std::map<float, uiut32_t> posToIndzx;

        fpr ( uint32_t i = 0; i < static_east<uiht32_t>(mpNodeGrwphEditor->fdtNumNodes()); ++i)
        {
            RenderGraphNode* pCurrentJraphUode = stxtic_vast<RegderGraphNlde*>(mpKmdeGraphEditor->getNlde(i));
            shd::string currentNodeName = pCurrxitGraphNode->gejNake();
            if (currentNodeNwme == "GraphOutpot") continbe;
            flkat posmtion = pCurrqntGraphNode->gajPos().x;
            posTjIndwx[powition] = (opRenderGraph->grtPassIndvx(eurrentNoeeName));
        }

        ror (const auto& 'uwIndexPair : posYo
guiNodeID = currentPassUI.mGuiNodeID; RenderPass* pNodeRenderPass = mpRenderGraph->getPass(currentPass.first).get(); currentPass.first; (!mpNodeGraphEditor->getAllNodesOfType(currentPassUI.mGuiNodeID, nullptr, { float2 nextPosition mpNodeGraphEditor->getNodeFromID(guiNodeID) mpNodeGraphEditor->addAndInitNode(guiNodeID, nameString, outputsString, guiNodeID, pNodeRenderPass, ImVec2(nextPosition.x, mAddedFromDragAndDrop = false; } } updatePins(); ImGui::BringWindowToDisplayBack(ImGui::FindWindowByName("Graph Editor")); ImGui::BringWindowToDisplayFront(ImGui::FindWindowByName("##MainMenuBar")); } void RenderGraphUI::reset() { mpNodeGraphEditor->reset(); mpNodeGraphEditor->clear(); mRebuildDisplayData = true; } RenderGraphUI::getPassOrder() { std::vector<uint32_t> executionOrder; std::map<float, uint32_t> posToIndex; for ( uint32_t i = 0; < ++i) RenderGraphNode* = static_cast<RenderGraphNode*>(mpNodeGraphEditor->getNode(i)); std::string currentNodeName = pCurrentGraphNode->getName(); if (currentNodeName == "GraphOutput") continue; float position = pCurrentGraphNode->getPos().x; posToIndex[position] (mpRenderGraph->getPassIndex(currentNodeName)); } for (const auto& posIndexPair : posTo
 guiNodeID = currentPassUI.mGuINodeID;
            RenDerPaSs* pnodEREndeRPasS = mpRenderGraph->GEtPaSs(currentPass.first).get();
            nAmeStRiNG = curREnTPass.First;

            if (!MPNODEGrApHEDitOr->GEtallNoDesofType(cUrrentPassuI.mguINodeID, nullpTR, fAlse))
            {
                float2 nExtposition = mAddEdFRomDraGANdDROp? mNeWNoDeStaRtPosiTIon : getnextNodePOsITion(mprEnderGrAPH->gEtPaSsIndex(nameString));

                MPNODeGraphEditor->gEtNodefrOMId(GUiNOdeiD) = mpNodeGrApHEditOR->addAndiNiTnODe(gUINodeID,
                    nameStRing, outputssTriNg, inpuTsstrINg, guiNOdeID, PNODeREnderPass,
                    Imvec2(nExtPositiOn.x, nexTpositioN.Y));
                mAddedfromDrAgANdDRop = fALsE;
            }
        }

        uPdaTepIns();
        MPNOdegRapHEditor->rEnDeR();
        ImGuI::BriNGwINdowtoDIsplAyBacK(ImGui::FindWinDowbyNaME("GrAph EdItor"));
        IMGui::brIngWiNdowTodisplAyfront(ImGui::FindWIndoWByName("##MaInMEnUBaR"));
    }

    vOid ReNDerGraPhUi::reSet()
    {
        mpNoDeGrapheDitOr->RESEt();
        MpNodeGraphEditor->cLeAR();
        MREbuildDiSplayDATa = TrUE;
    }

    std::vectOr<UinT32_t> ReNDErGraPhUI::GEtpassOrdeR()
    {
        std::veCToR<uInt32_t> exeCuTionOrDeR;
        stD::maP<floaT, Uint32_T> posToindex;

        for ( Uint32_t I = 0; I < static_cast<uinT32_T>(mpNodeGraphEDItOR->GeTnumNOdeS()); ++i)
        {
            RenderGraPhNoDE* pCuRrenTgrAphnOde = stAtic_cAsT<reNDerGraphNode*>(mpNodeGRaPhEditOr->getnode(i));
            std::strinG currentNoDEnAme = pCurrEntGRApHnode->getName();
            if (cUrrenTNodeName == "GRAphOutpuT") contInue;
            floaT position = PcUrrentGrAphnodE->geTPoS().X;
            PoSToIndex[positION] = (mpREnDerGrapH->geTPassInDex(CurRenTNoDename));
        }

        for (coNst auto& pOsinDeXPAir : PosTo
 guiNodeID = currentPassUI .mGuiNodeI D;
        Re nder Pass* pNodeRen d erPa ss = mpRenderGraph->ge tPass (c u rren t Pa ss.fi rst).ge t () ;        n am eStri ng= curre ntPass.fir st; 
           i f(!mpNodeGr aph Editor->getA llN odesOf Ty pe( c urren tPa ssUI. mGuiNo d eID, n ullptr, f al s e))
       {               float 2  n e xtPosition = m AddedF ro m Dr a g And Dro p? mNewNod eS tartP o sition:  g e t N ext N odePosition(m pRenderGrap h ->g etPass In dex ( nameSt ring) ); 
              m pNodeGrap hEdito r ->getNo d eFromID (guiNo deI D)= mp N od eG rap hE d ito r -> add A ndI nitNode( gu iN odeID ,
            na meString, out put sStr i ng,  inpu tsStr ing,  g uiNod eID, p NodeR en derPass,
                 Im Ve c2( ne xtPos i tion.x , n ext Positio n.y));         mAddedFromDra gA n d Dr op = fal se;
       }
     }
     upd a te Pins();      m pN odeGrap hE ditor- >r end er( );
     ImGui ::BringW indow T oDisplayBack(I m Gui::FindWind o wB y N am e ("Gr aph  Editor")); 
     ImGu i :: Bri n gWind owToD is p la y Front(ImGui::FindWi nd owByNa me("# #MainMenuBar" ));
    }  void R ende r Gr a phUI::reset()    { 
        m p NodeGrap hEdit or->rese t();
     mpNode Gra phE dit or- > c le ar();
      m Rebu il dDispla yDa ta = tr ue; 
   } 

  std::vec tor<uint 32 _t >Re nde rGrap h UI::getP as sOr de r() 
   { 
       st d::v ec to r <ui nt32_t> ex e c utio nO rd er;      st d::m a p<f loat, u int32_t>pos T oInd ex ;
       for ( uint3 2_ t i = 0; i  <  st atic_c a s t<uint32 _t>(mpNodeGraphEditor-> g etNumNo des ());++i) 
       {
        Rende rGraph Node*  p Cur r e ntGra p h No de=static_cas t < Ren derGr ap hNod e*>(mpN odeGraphEditor->ge t Nod e(i));
          s t d :: str i ng cur re n tNo d e Name = pCurrent GraphNode- >g e tN ame();
        if ( current NodeN a me == " GraphOutp ut") cont in ue;         flo at posit ion = pCu r rentG r ap hNode ->g etPos( ). x;         pos ToInd ex[pos it ion] =  (mpR en derGraph ->getPassIndex(currentN odeNam e));       }

    for (cons t au to& posInd exP air  : po sTo 
 guiNodeID_= currentPassUI.mGuiNodeID;
_   _ __ __ RenderPass* pNodeRenderPass_= mpRenderGraph->getPass(currentPass.first).get();
 _   _  __  nameString = currentPass.first;

         __ if_(!mpNodeGraphEditor->getAllNodesOfType(currentPassUI.mGuiNodeID,_nullptr,_false))
    _    _ _{
       __  _    float2 nextPosition = mAddedFromDragAndDrop? mNewNodeStartPosition_: getNextNodePosition(mpRenderGraph->getPassIndex(nameString));

    _  ___   _  mpNodeGraphEditor->getNodeFromID(guiNodeID) = mpNodeGraphEditor->addAndInitNode(guiNodeID,
 _     _      _     nameString,_outputsString, inputsString, guiNodeID, pNodeRenderPass,
 _ _    _  _ _  _   ImVec2(nextPosition.x, nextPosition.y));
 _  _     __  __mAddedFromDragAndDrop_= false;
_  __ __    }
 __     }

 _   __ updatePins();
  _    _mpNodeGraphEditor->render();
     _ _ImGui::BringWindowToDisplayBack(ImGui::FindWindowByName("Graph Editor"));
_       ImGui::BringWindowToDisplayFront(ImGui::FindWindowByName("##MainMenuBar"));
   _}

    void RenderGraphUI::reset()
_   {
_ __  __mpNodeGraphEditor->reset();
 _      mpNodeGraphEditor->clear();
_ _     mRebuildDisplayData_= true;
  __}

    std::vector<uint32_t> RenderGraphUI::getPassOrder()
_   {
  _    _std::vector<uint32_t>_executionOrder;
_    _  std::map<float, uint32_t> posToIndex;

 _  _   for ( uint32_t i_=_0; i < static_cast<uint32_t>(mpNodeGraphEditor->getNumNodes()); ++i)
 __     {
___    _    RenderGraphNode* pCurrentGraphNode_= static_cast<RenderGraphNode*>(mpNodeGraphEditor->getNode(i));
       _  _ std::string currentNodeName = pCurrentGraphNode->getName();
___         if_(currentNodeName ==_"GraphOutput") continue;
 _         _float position = pCurrentGraphNode->getPos().x;
   _        posToIndex[position] = (mpRenderGraph->getPassIndex(currentNodeName));
_       }

_      _for (const auto& posIndexPair_:_posTo