BVB Source Codes

CRYENGINE Show FlowGraph.h Source code

Return Download CRYENGINE: download FlowGraph.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __FLOWGRAPH_H__
  4. #define __FLOWGRAPH_H__
  5.  
  6. #pragma once
  7.  
  8. #include "FlowSystem.h"
  9. #include "FlowData.h"
  10. #include <CryString/StringUtils.h>
  11.  
  12. #include <CryFlowGraph/IFlowGraphDebugger.h>
  13.  
  14. // class CFlowSystem;
  15.  
  16. //#undef  FLOW_DEBUG_PENDING_UPDATES
  17.  
  18. #define MAX_GRAPH_ENTITIES 2
  19. #define ALLOW_MULTIPLE_PORT_ACTIVATIONS_PER_UPDATE
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. class CFlowGraphBase : public IFlowGraph
  23. {
  24. public:
  25.         CFlowGraphBase(CFlowSystem* pSys);
  26.         virtual ~CFlowGraphBase();
  27.  
  28.         // IFlowGraph
  29.         virtual void          AddRef();
  30.         virtual void          Release();
  31.         virtual IFlowGraphPtr Clone();
  32.         virtual void          Clear();
  33.         virtual void RegisterHook(IFlowGraphHookPtr);
  34.         virtual void UnregisterHook(IFlowGraphHookPtr);
  35.         virtual IFlowNodeIteratorPtr       CreateNodeIterator();
  36.         virtual IFlowEdgeIteratorPtr       CreateEdgeIterator();
  37.         virtual void                       SetUserData(TFlowNodeId id, const XmlNodeRef& data);
  38.         virtual XmlNodeRef                 GetUserData(TFlowNodeId id);
  39.         virtual void                       SetGraphEntity(EntityId id, int nIndex = 0);
  40.         virtual EntityId                   GetGraphEntity(int nIndex) const;
  41.         virtual SFlowAddress               ResolveAddress(const char* addr, bool isOutput);
  42.         virtual TFlowNodeId                ResolveNode(const char* name);
  43.         virtual void                       GetNodeConfiguration(TFlowNodeId id, SFlowNodeConfig&);
  44.         virtual bool                       LinkNodes(SFlowAddress from, SFlowAddress to);
  45.         virtual void                       UnlinkNodes(SFlowAddress from, SFlowAddress to);
  46.         virtual TFlowNodeId                CreateNode(TFlowNodeTypeId typeId, const char* name, void* pUserData = 0);
  47.         virtual TFlowNodeId                CreateNode(const char* typeName, const char* name, void* pUserData = 0);
  48.         virtual bool                       SetNodeName(TFlowNodeId id, const char* sName);
  49.         virtual IFlowNodeData*             GetNodeData(TFlowNodeId id);
  50.         virtual const char*                GetNodeName(TFlowNodeId id);
  51.         virtual TFlowNodeTypeId            GetNodeTypeId(TFlowNodeId id);
  52.         virtual const char*                GetNodeTypeName(TFlowNodeId id);
  53.         virtual void                       RemoveNode(const char* name);
  54.         virtual void                       RemoveNode(TFlowNodeId id);
  55.         virtual void                       SetEnabled(bool bEnabled);
  56.         virtual bool                       IsEnabled() const { return m_bEnabled; }
  57.         virtual void                       SetActive(bool bActive);
  58.         virtual bool                       IsActive() const  { return m_bActive; }
  59.         virtual void                       UnregisterFromFlowSystem();
  60.  
  61.         virtual void                       SetType(IFlowGraph::EFlowGraphType type) { m_Type = type; }
  62.         virtual IFlowGraph::EFlowGraphType GetType() const                          { return m_Type; }
  63.  
  64.         virtual void                       RegisterFlowNodeActivationListener(SFlowNodeActivationListener* listener);
  65.         virtual void                       RemoveFlowNodeActivationListener(SFlowNodeActivationListener* listener);
  66.  
  67.         virtual void                       Update();
  68.         virtual void                       InitializeValues();
  69.         virtual bool                       SerializeXML(const XmlNodeRef& root, bool reading);
  70.         virtual void                       Serialize(TSerialize ser);
  71.         virtual void                       PostSerialize();
  72.         virtual void                       SetRegularlyUpdated(TFlowNodeId id, bool regularly);
  73.         virtual void RequestFinalActivation(TFlowNodeId);
  74.         virtual void                       ActivateNode(TFlowNodeId id) { ActivateNodeInt(id); }
  75.         virtual void                       ActivatePortAny(SFlowAddress output, const TFlowInputData&);
  76.         virtual void                       ActivatePortCString(SFlowAddress output, const char* cstr);
  77.         virtual bool                       SetInputValue(TFlowNodeId node, TFlowPortId port, const TFlowInputData&);
  78.         virtual bool                       IsOutputConnected(SFlowAddress output);
  79.         virtual const TFlowInputData*      GetInputValue(TFlowNodeId node, TFlowPortId port);
  80.         virtual bool                       GetActivationInfo(const char* nodeName, IFlowNode::SActivationInfo& actInfo);
  81.         virtual void     SetEntityId(TFlowNodeId, EntityId);
  82.         virtual EntityId GetEntityId(TFlowNodeId);
  83.  
  84.         virtual IFlowGraphPtr                  GetClonedFlowGraph() const { return m_pClonedFlowGraph; }
  85.  
  86.         virtual void                           PrecacheResources();
  87.  
  88.         virtual void                           RemoveGraphTokens();
  89.         virtual bool                           AddGraphToken(const IFlowGraph::SGraphToken& token);
  90.         virtual size_t                         GetGraphTokenCount() const;
  91.         virtual const IFlowGraph::SGraphToken* GetGraphToken(size_t index) const;
  92.         virtual string                         GetGlobalNameForGraphToken(const string& tokenName) const;
  93.  
  94.         virtual TFlowGraphId                   GetGraphId() const { return m_graphId; }
  95.  
  96.         virtual void                           EnsureSortedEdges()
  97.         {
  98.                 if (!m_bEdgesSorted)
  99.                         SortEdges();
  100.         }
  101.         // ~IFlowGraph
  102.  
  103.         virtual void GetMemoryUsage(ICrySizer* s) const;
  104.  
  105.         // temporary solutions [ ask Dejan ]
  106.  
  107.         // Suspended flow graphs were needed for AI Action flow graphs.
  108.         // Suspended flow graphs aren't updated...
  109.         // Nodes in suspended flow graphs should ignore OnEntityEvent notifications!
  110.         virtual void SetSuspended(bool suspend = true);
  111.         virtual bool IsSuspended() const;
  112.  
  113.         // AI action related
  114.         virtual void       SetAIAction(IAIAction* pAIAction);
  115.         virtual IAIAction* GetAIAction() const;
  116.  
  117.         // Custom action related
  118.         virtual void           SetCustomAction(ICustomAction* pCustomAction);
  119.         virtual ICustomAction* GetCustomAction() const;
  120.         IFlowGraphPtr          GetClonedFlowGraph() { return m_pClonedFlowGraph; }
  121.  
  122.         //////////////////////////////////////////////////////////////////////////
  123.         IEntity* GetIEntityForNode(TFlowNodeId id);
  124.  
  125.         // Called only from CFlowSystem::~CFlowSystem()
  126.         void                                       NotifyFlowSystemDestroyed();
  127.  
  128.         void                                       RegisterInspector(IFlowGraphInspectorPtr pInspector);
  129.         void                                       UnregisterInspector(IFlowGraphInspectorPtr pInspector);
  130.         const std::vector<IFlowGraphInspectorPtr>& GetInspectors() const { return m_inspectors; }
  131.  
  132.         CFlowSystem*                               GetSys() const        { return m_pSys; }
  133.  
  134.         // get some more stats
  135.         void GetGraphStats(int& nodeCount, int& edgeCount);
  136.  
  137.         void OnEntityReused(IEntity* pEntity, SEntitySpawnParams& params);
  138.         void OnEntityIdChanged(EntityId oldId, EntityId newId);
  139.         void UpdateForwardings();
  140.  
  141.         bool NotifyFlowNodeActivationListeners(TFlowNodeId srcNode, TFlowPortId srcPort, TFlowNodeId toNode, TFlowPortId toPort, const char* value);
  142.  
  143. protected:
  144.  
  145.         // helper to broadcast an activation
  146.         template<class T>
  147.         void PerformActivation(const SFlowAddress, const T& value);
  148.  
  149.         void CloneInner(CFlowGraphBase* pClone);
  150.  
  151. private:
  152.         void ResetGraphToken(const IFlowGraph::SGraphToken& token);
  153.  
  154.         class CNodeIterator;
  155.         class CEdgeIterator;
  156.  
  157.         void       FlowLoadError(const char* format, ...) PRINTF_PARAMS(2, 3);
  158.  
  159.         ILINE void NeedUpdate()
  160.         {
  161.                 m_bNeedsUpdating = true;
  162.         }
  163.         ILINE void ActivateNodeInt(TFlowNodeId id)
  164.         {
  165.                 if (m_modifiedNodes[id] == NOT_MODIFIED)
  166.                 {
  167.                         m_modifiedNodes[id] = m_firstModifiedNode;
  168.                         m_firstModifiedNode = id;
  169.                 }
  170.                 if (!m_bInUpdate)
  171.                         NeedUpdate();
  172.         }
  173.         IFlowNodePtr CreateNodeOfType(IFlowNode::SActivationInfo* pInfo, TFlowNodeTypeId typeId);
  174.         void         SortEdges();
  175.         TFlowNodeId  AllocateId();
  176.         void DeallocateId(TFlowNodeId);
  177.         bool ValidateAddress(SFlowAddress);
  178.         bool ValidateNode(TFlowNodeId) const;
  179.         bool                               ValidateLink(SFlowAddress& from, SFlowAddress& to);
  180.         static void                        RemoveNodeFromActivationArray(TFlowNodeId id, TFlowNodeId& front, std::vector<TFlowNodeId>& array);
  181.         void                               Cleanup();
  182.         bool                               ReadXML(const XmlNodeRef& root);
  183.         bool                               WriteXML(const XmlNodeRef& root);
  184.         std::pair<CFlowData*, TFlowNodeId> CreateNodeInt(TFlowNodeTypeId typeId, const char* name, void* pUserData = 0);
  185.         string                             PrettyAddress(SFlowAddress addr);
  186.         SFlowAddress                       ResolveAddress(const string& node, const string& port, bool isOutput)
  187.         {
  188.                 return ResolveAddress(node.c_str(), port.c_str(), isOutput);
  189.         }
  190.         SFlowAddress ResolveAddress(const char* node, const char* port, bool isOutput);
  191.         void         DoUpdate(IFlowNode::EFlowEvent event);
  192.         void         NeedInitialize()
  193.         {
  194.                 m_bNeedsInitialize = true;
  195.                 NeedUpdate();
  196.         }
  197.  
  198.         template<class T>
  199.         inline string ToString(const T& value);
  200.  
  201.         template<class T>
  202.         bool        NotifyFlowNodeActivationListeners(TFlowNodeId srcNode, TFlowPortId srcPort, TFlowNodeId toNode, TFlowPortId toPort, const T& value);
  203.  
  204.         const char* InternalGetDebugName();
  205.  
  206. #if defined (FLOW_DEBUG_PENDING_UPDATES)
  207.         void DebugPendingActivations();
  208.         void CreateDebugName();
  209.         // a more or less descriptive name
  210.         string m_debugName;
  211. #endif
  212.  
  213.         // the set of modified nodes
  214.         // not modified marker
  215.         static const TFlowNodeId NOT_MODIFIED
  216. #if !defined(__GNUC__)
  217.           = ~TFlowNodeId(0)
  218. #endif
  219.         ;
  220.         // end of modified list marker
  221.         static const TFlowNodeId END_OF_MODIFIED_LIST
  222. #if !defined(__GNUC__)
  223.           = NOT_MODIFIED - 1
  224. #endif
  225.         ;
  226.         // PerformActivation works with this
  227.         std::vector<TFlowNodeId>                  m_modifiedNodes;
  228.         // This list is used for flowgraph debugging
  229.         std::vector<SFlowNodeActivationListener*> m_flowNodeActivationListeners;
  230.         // and Update swaps modifiedNodes and this so that we don't get messed
  231.         // up during the activation sweep
  232.         std::vector<TFlowNodeId> m_activatingNodes;
  233.         // and this is the head of m_modifiedNodes
  234.         TFlowNodeId              m_firstModifiedNode;
  235.         // and this is the head of m_activatingNodes
  236.         TFlowNodeId              m_firstActivatingNode;
  237.         // are we in an update loop?
  238.         bool                     m_bInUpdate;
  239.         // Activate may request a final activation; these get inserted here, and we
  240.         // sweep through it at the end of the update process
  241.         std::vector<TFlowNodeId> m_finalActivatingNodes;
  242.         TFlowNodeId              m_firstFinalActivatingNode;
  243.  
  244.         // all of the node data
  245.         std::vector<CFlowData>   m_flowData;
  246.         // deallocated id's waiting to be reused
  247.         std::vector<TFlowNodeId> m_deallocatedIds;
  248.  
  249.         // a link between nodes
  250.         struct SEdge
  251.         {
  252.                 ILINE SEdge() : fromNode(InvalidFlowNodeId), toNode(InvalidFlowNodeId), fromPort(InvalidFlowPortId), toPort(InvalidFlowPortId) {}
  253.                 ILINE SEdge(SFlowAddress from, SFlowAddress to) : fromNode(from.node), toNode(to.node), fromPort(from.port), toPort(to.port)
  254.                 {
  255.                         CRY_ASSERT(from.isOutput);
  256.                         CRY_ASSERT(!to.isOutput);
  257.                 }
  258.                 ILINE SEdge(TFlowNodeId fromNode_, TFlowPortId fromPort_, TFlowNodeId toNode_, TFlowPortId toPort_) : fromNode(fromNode_), toNode(toNode_), fromPort(fromPort_), toPort(toPort_) {}
  259.  
  260.                 TFlowNodeId fromNode;
  261.                 TFlowNodeId toNode;
  262.                 TFlowPortId fromPort;
  263.                 TFlowPortId toPort;
  264.  
  265.                 ILINE bool operator<(const SEdge& rhs) const
  266.                 {
  267.                         if (fromNode < rhs.fromNode)
  268.                                 return true;
  269.                         else if (fromNode > rhs.fromNode)
  270.                                 return false;
  271.                         else if (fromPort < rhs.fromPort)
  272.                                 return true;
  273.                         else if (fromPort > rhs.fromPort)
  274.                                 return false;
  275.                         else if (toNode < rhs.toNode)
  276.                                 return true;
  277.                         else if (toNode > rhs.toNode)
  278.                                 return false;
  279.                         else if (toPort < rhs.toPort)
  280.                                 return true;
  281.                         else
  282.                                 return false;
  283.                 }
  284.                 ILINE bool operator==(const SEdge& rhs) const
  285.                 {
  286.                         return fromNode == rhs.fromNode && fromPort == rhs.fromPort &&
  287.                                toNode == rhs.toNode && toPort == rhs.toPort;
  288.                 }
  289.  
  290.                 void GetMemoryUsage(ICrySizer* pSizer) const {}
  291.         };
  292.         class SEdgeHasNode;
  293.         std::vector<SEdge> m_edges;
  294.         bool               m_bEnabled;
  295.         bool               m_bActive;
  296.         bool               m_bEdgesSorted;
  297.         bool               m_bNeedsInitialize;
  298.         bool               m_bNeedsUpdating;
  299.         CFlowSystem*       m_pSys;
  300.  
  301.         // all of the regularly updated nodes (there aught not be too many)
  302.         typedef std::vector<TFlowNodeId> RegularUpdates;
  303.         RegularUpdates m_regularUpdates;
  304.         RegularUpdates m_activatingUpdates;
  305.         EntityId       m_graphEntityId[MAX_GRAPH_ENTITIES];
  306.  
  307.         // reference count
  308.         int m_nRefs;
  309.  
  310.         // nodes -> id resolution
  311.         std::map<string, TFlowNodeId>       m_nodeNameToId;
  312.         // hooks
  313.         std::vector<IFlowGraphHookPtr>      m_hooks;
  314.         // user data for editor
  315.         std::map<TFlowNodeId, XmlNodeRef>   m_userData;
  316.         // inspectors
  317.         std::vector<IFlowGraphInspectorPtr> m_inspectors;
  318.  
  319.         IEntitySystem*                      m_pEntitySystem;
  320.  
  321.         // temporary solutions [ ask Dejan ]
  322.         bool m_bSuspended;
  323.         bool m_bIsAIAction; // flag that this FlowGraph is an AIAction
  324.         //                     first and only time set in SetAIAction call with an action != 0
  325.         //                     it is never reset. needed when activations are pending which is o.k. for Actiongraphs
  326.         IAIAction* m_pAIAction;
  327.  
  328.         bool       m_bRegistered;
  329.  
  330.         bool       m_bIsCustomAction; // flag that this FlowGraph is an AIAction
  331.         //                     first and only time set in SetAIAction call with an action != 0
  332.         //                     it is never reset. needed when activations are pending which is o.k. for Actiongraphs
  333.         ICustomAction*             m_pCustomAction;
  334.  
  335.         IFlowGraphPtr              m_pClonedFlowGraph;
  336.  
  337.         TFlowGraphId               m_graphId;
  338.         typedef std::vector<IFlowGraph::SGraphToken> TGraphTokens;
  339.         TGraphTokens               m_graphTokens;
  340.  
  341.         IFlowGraph::EFlowGraphType m_Type;
  342.         IFlowGraphDebuggerPtr      m_pFlowGraphDebugger;
  343.  
  344. #if defined(ALLOW_MULTIPLE_PORT_ACTIVATIONS_PER_UPDATE)
  345.         struct SCachedActivation
  346.         {
  347.                 SCachedActivation()
  348.                         : portID(InvalidFlowPortId)
  349.                 {}
  350.  
  351.                 template<class T>
  352.                 SCachedActivation(const TFlowPortId& inputPortID, const T& inputValue)
  353.                         : portID(inputPortID)
  354.                         , value(inputValue)
  355.                 {}
  356.  
  357.                 TFlowPortId    portID;
  358.                 TFlowInputData value;
  359.         };
  360.  
  361.         typedef std::vector<SCachedActivation>                TCachedPortActivations;
  362.         typedef std::map<TFlowNodeId, TCachedPortActivations> TCachedActivations;
  363.         TCachedActivations m_cachedActivations;
  364. #endif
  365. };
  366.  
  367. template<class T>
  368. inline string CFlowGraphBase::ToString(const T& value)
  369. {
  370.         return CryStringUtils::toString(value);
  371. }
  372.  
  373. template<>
  374. inline string CFlowGraphBase::ToString(const string& value)
  375. {
  376.         return value;
  377. }
  378.  
  379. template<>
  380. inline string CFlowGraphBase::ToString(const SFlowSystemVoid& value)
  381. {
  382.         return "unknown";
  383. }
  384.  
  385. template<>
  386. inline string CFlowGraphBase::ToString(const TFlowInputData& value)
  387. {
  388.         switch (value.GetType())
  389.         {
  390.         case eFDT_EntityId:
  391.                 return ToString(*value.GetPtr<EntityId>());
  392.         case eFDT_String:
  393.                 return ToString(*value.GetPtr<string>());
  394.         case eFDT_Float:
  395.                 return ToString(*value.GetPtr<float>());
  396.         case eFDT_Vec3:
  397.                 return ToString(*value.GetPtr<Vec3>());
  398.         case eFDT_Bool:
  399.                 return ToString(*value.GetPtr<bool>());
  400.         case eFDT_Int:
  401.                 return ToString(*value.GetPtr<int>());
  402.         default:
  403.                 return "unknown";
  404.         }
  405. }
  406.  
  407. template<class T>
  408. bool CFlowGraphBase::NotifyFlowNodeActivationListeners(TFlowNodeId srcNode, TFlowPortId srcPort, TFlowNodeId toNode, TFlowPortId toPort, const T& value)
  409. {
  410.         const string val = ToString(value);
  411.         return NotifyFlowNodeActivationListeners(srcNode, srcPort, toNode, toPort, val.c_str());
  412. }
  413.  
  414. // this function is only provided to assist implementation of ActivatePort()
  415. // force it inline for code size
  416. template<class T>
  417. ILINE void CFlowGraphBase::PerformActivation(const SFlowAddress addr, const T& value)
  418. {
  419.         FUNCTION_PROFILER(gEnv->pSystem, PROFILE_ACTION);
  420.         CRY_ASSERT(ValidateAddress(addr));
  421.  
  422.         if (m_bActive == false || m_bEnabled == false)
  423.                 return;
  424.  
  425.         static ICVar* pToggleDebugger = NULL;
  426.  
  427.         if (!pToggleDebugger)
  428.                 pToggleDebugger = gEnv->pConsole->GetCVar("fg_iEnableFlowgraphNodeDebugging");
  429.  
  430.         if (addr.isOutput)
  431.         {
  432.                 EnsureSortedEdges();
  433.  
  434.                 TFlowInputData valueData;
  435.                 valueData.SetUserFlag(true);
  436.                 valueData.SetValueWithConversion(value);
  437.  
  438.                 int edgeIndex = 0;
  439.                 const bool bFlowGraphDebuggerEnabled = (pToggleDebugger && pToggleDebugger->GetIVal() > 0);
  440.                 const bool notify = gEnv->IsEditor() && m_pFlowGraphDebugger && bFlowGraphDebuggerEnabled && !m_bNeedsInitialize;
  441.                 const int firstEdgeIndex = m_flowData[addr.node].GetOutputFirstEdge(addr.port);
  442.  
  443.                 if (notify && !IsOutputConnected(addr))
  444.                 {
  445.                         if (!m_pFlowGraphDebugger->PerformActivation(this, addr, valueData))
  446.                                 return;
  447.                 }
  448. #if defined(ALLOW_MULTIPLE_PORT_ACTIVATIONS_PER_UPDATE)
  449.                 std::vector<TFlowNodeId> tempNodeIDs;
  450. #endif
  451.                 std::vector<SEdge>::const_iterator iter = m_edges.begin() + firstEdgeIndex;
  452.                 std::vector<SEdge>::const_iterator iterEnd = m_edges.end();
  453.                 while (iter != iterEnd && iter->fromNode == addr.node && iter->fromPort == addr.port)
  454.                 {
  455.                         if (notify)
  456.                         {
  457.                                 SFlowAddress fromAddr;
  458.                                 fromAddr.node = iter->fromNode;
  459.                                 fromAddr.port = iter->fromPort;
  460.                                 fromAddr.isOutput = true;
  461.  
  462.                                 SFlowAddress toAddr;
  463.                                 toAddr.node = iter->toNode;
  464.                                 toAddr.port = iter->toPort;
  465.                                 toAddr.isOutput = false;
  466.  
  467.                                 if (!m_pFlowGraphDebugger->PerformActivation(this, edgeIndex, fromAddr, toAddr, valueData))
  468.                                         return;
  469.                         }
  470. #if defined(ALLOW_MULTIPLE_PORT_ACTIVATIONS_PER_UPDATE)
  471.                         if (!m_bNeedsInitialize && m_flowData[iter->toNode].GetInputPort(iter->toPort)->IsUserFlagSet())
  472.                         {
  473.                                 tempNodeIDs.push_back(iter->toNode);
  474.                                 // cache multiple port activations per update
  475.                                 TCachedActivations::iterator cachedIter = m_cachedActivations.find(iter->toNode);
  476.  
  477.                                 if (cachedIter != m_cachedActivations.end())
  478.                                 {
  479.                                         SCachedActivation cachedActivation(iter->toPort, value);
  480.  
  481.                                         // Check if this port is already in the cache
  482.                                         TCachedPortActivations::iterator dupCheckIter = cachedIter->second.begin();
  483.                                         TCachedPortActivations::iterator dupCheckIterEnd = cachedIter->second.end();
  484.                                         for (; dupCheckIter != dupCheckIterEnd; ++dupCheckIter)
  485.                                         {
  486.                                                 if (iter->toPort == dupCheckIter->portID)
  487.                                                 {
  488.                                                         break;
  489.                                                 }
  490.                                         }
  491.                                         // If it is, we're probably in a loop
  492.                                         if (dupCheckIter == dupCheckIterEnd)
  493.                                         {
  494.                                                 cachedIter->second.push_back(cachedActivation);
  495.                                         }
  496.                                 }
  497.                                 else
  498.                                 {
  499.                                         SCachedActivation cachedActivation(iter->toPort, value);
  500.  
  501.                                         TCachedPortActivations activation;
  502.                                         activation.push_back(cachedActivation);
  503.                                         m_cachedActivations.insert(std::make_pair(iter->toNode, activation));
  504.                                 }
  505.                         }
  506.                         else
  507. #endif
  508.                         {
  509.                                 m_flowData[iter->toNode].ActivateInputPort(iter->toPort, value);
  510.                                 // see if we need to insert this node into the modified list
  511.                                 ActivateNodeInt(iter->toNode);
  512.                         }
  513.  
  514.                         if (notify)
  515.                                 NotifyFlowNodeActivationListeners(iter->fromNode, iter->fromPort, iter->toNode, iter->toPort, value);
  516.  
  517.                         if (m_pSys && m_pSys->IsInspectingEnabled())
  518.                                 m_pSys->NotifyFlow(this, addr, SFlowAddress(iter->toNode, iter->toPort, false));
  519.  
  520.                         ++iter;
  521.                         ++edgeIndex;
  522.                 }
  523. #if defined(ALLOW_MULTIPLE_PORT_ACTIVATIONS_PER_UPDATE)
  524.                 if (!m_cachedActivations.empty())
  525.                 {
  526.                         // add a separator for each cached activation so we can send the activate event after the port values were set
  527.                         std::vector<TFlowNodeId>::const_iterator nodeIter = tempNodeIDs.begin();
  528.                         for (; nodeIter != tempNodeIDs.end(); ++nodeIter)
  529.                         {
  530.                                 TCachedActivations::iterator cachedIter = m_cachedActivations.find(*nodeIter);
  531.  
  532.                                 if (cachedIter != m_cachedActivations.end())
  533.                                 {
  534.                                         SCachedActivation invalidCachedActivation;
  535.                                         // If last cache entry is already a separator, don't add another one
  536.                                         if (cachedIter->second.rbegin()->portID != invalidCachedActivation.portID)
  537.                                                 cachedIter->second.push_back(invalidCachedActivation);
  538.                                 }
  539.                         }
  540.                 }
  541. #endif
  542.         }
  543.         else
  544.         {
  545.                 if (m_flowData[addr.node].GetImpl())
  546.                 {
  547.                         m_flowData[addr.node].ActivateInputPort(addr.port, value);
  548.                         ActivateNodeInt(addr.node);
  549.                 }
  550.         }
  551. }
  552.  
  553. class CFlowGraph : public CFlowGraphBase
  554. {
  555. public:
  556.         CFlowGraph(CFlowSystem* pSys) : CFlowGraphBase(pSys) {}
  557.         virtual void GetMemoryUsage(ICrySizer* s) const;
  558.  
  559.         virtual void DoActivatePort(const SFlowAddress address, const NFlowSystemUtils::Wrapper<SFlowSystemVoid>& value)
  560.         {
  561.                 CFlowGraphBase::PerformActivation(address, value.value);
  562.         }
  563.         virtual void DoActivatePort(const SFlowAddress address, const NFlowSystemUtils::Wrapper<int>& value)
  564.         {
  565.                 CFlowGraphBase::PerformActivation(address, value.value);
  566.         }
  567.         virtual void DoActivatePort(const SFlowAddress address, const NFlowSystemUtils::Wrapper<float>& value)
  568.         {
  569.                 CFlowGraphBase::PerformActivation(address, value.value);
  570.         }
  571.         virtual void DoActivatePort(const SFlowAddress address, const NFlowSystemUtils::Wrapper<EntityId>& value)
  572.         {
  573.                 CFlowGraphBase::PerformActivation(address, value.value);
  574.         }
  575.         virtual void DoActivatePort(const SFlowAddress address, const NFlowSystemUtils::Wrapper<Vec3>& value)
  576.         {
  577.                 CFlowGraphBase::PerformActivation(address, value.value);
  578.         }
  579.         virtual void DoActivatePort(const SFlowAddress address, const NFlowSystemUtils::Wrapper<string>& value)
  580.         {
  581.                 CFlowGraphBase::PerformActivation(address, value.value);
  582.         }
  583.         virtual void DoActivatePort(const SFlowAddress address, const NFlowSystemUtils::Wrapper<bool>& value)
  584.         {
  585.                 CFlowGraphBase::PerformActivation(address, value.value);
  586.         }
  587. };
  588.  
  589. #endif
  590.  
downloadFlowGraph.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top