BVB Source Codes

CRYENGINE Show FlashUIBaseNode.h Source code

Return Download CRYENGINE: download FlashUIBaseNode.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   FlashUIBaseNode.h
  5. //  Version:     v1.00
  6. //  Created:     10/9/2010 by Paul Reindell.
  7. //  Description:
  8. // -------------------------------------------------------------------------
  9. //  History:
  10. //
  11. ////////////////////////////////////////////////////////////////////////////
  12. #pragma once
  13.  
  14. #include "FlashUI.h"
  15. #include <CryFlowGraph/IFlowBaseNode.h>
  16.  
  17. #ifndef RELEASE
  18.         #define ENABLE_UISTACK_DEBUGGING
  19. #endif
  20.  
  21. // ---------------------------------------------------------------
  22. // ---------------------- ui base nodes ---------------------------
  23. // ---------------------------------------------------------------
  24. class CFlashUIBaseNode : public CFlowBaseNode<eNCT_Instanced>
  25. {
  26. public:
  27.         CFlashUIBaseNode();
  28.         virtual ~CFlashUIBaseNode() {};
  29.  
  30.         virtual void            GetMemoryUsage(ICrySizer* s) const { s->Add(*this); }
  31.         virtual IFlowNodePtr    Clone(SActivationInfo* pActInfo) = 0;
  32.  
  33.         static SInputPortConfig CreateInstanceIdPort();
  34.         static SInputPortConfig CreateElementsPort();
  35.         static SInputPortConfig CreateVariablesPort();
  36.         static SInputPortConfig CreateArraysPort();
  37.         static SInputPortConfig CreateMovieClipsPort();
  38.         static SInputPortConfig CreateMovieClipsParentPort();
  39.         static SInputPortConfig CreateMovieClipTmplPort();
  40.         static SInputPortConfig CreateVariablesForTmplPort();
  41.         static SInputPortConfig CreateArraysForTmplPort();
  42.         static SInputPortConfig CreateMovieClipsForTmplPort();
  43.         static SInputPortConfig CreateTmplInstanceNamePort();
  44.  
  45.         void                    UpdateUIElement(const string& sName, SActivationInfo* pActInfo);
  46.  
  47.         inline IUIElement*      GetElement() const { return m_pElement; }
  48.         inline IUIElement*      GetInstance(int instanceID);
  49.  
  50. private:
  51.         IUIElement* m_pElement;
  52. };
  53.  
  54. // ---------------------------------------------------------------
  55. template<EUIObjectType Type>
  56. class CFlashUIBaseDescNode : public CFlashUIBaseNode
  57. {
  58. public:
  59.         CFlashUIBaseDescNode() : m_pObjectDesc(NULL), m_pTmplDesc(NULL) {}
  60.  
  61.         virtual void         GetConfiguration(SFlowNodeConfig&)               { assert(false); };
  62.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo*) { assert(false); };
  63.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)                 { assert(false); return new CFlashUIBaseDescNode(); }
  64.  
  65.         void                 UpdateObjectDesc(const string& sInputStr, SActivationInfo* pActInfo, bool isTemplate)
  66.         {
  67.                 m_pObjectDesc = NULL;
  68.  
  69.                 SUIArguments path;
  70.                 path.SetDelimiter(":");
  71.                 path.SetArguments(sInputStr.c_str());
  72.  
  73.                 if (path.GetArgCount() > 1)
  74.                 {
  75.                         string sUIElement;
  76.                         path.GetArg(0, sUIElement);
  77.                         UpdateUIElement(sUIElement, pActInfo);
  78.  
  79.                         if (GetElement())
  80.                         {
  81.                                 if (isTemplate)
  82.                                         m_pObjectDesc = UpdateObjectDescInt<eUOT_MovieClipTmpl>(GetElement(), path, 1);
  83.                                 else
  84.                                         m_pObjectDesc = UpdateObjectDescInt<eUOT_MovieClip>(GetElement(), path, 1);
  85.                                 if (!m_pObjectDesc && !isTemplate)
  86.                                 {
  87.                                         UIACTION_WARNING("FG: UIElement \"%s\" does not have %s \"%s\", referenced at node \"%s\"", GetElement()->GetName(), SUIGetTypeStr<Type>::GetTypeName(), sInputStr.c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  88.                                 }
  89.                                 return;
  90.                         }
  91.                         UIACTION_WARNING("FG: Path To object \"%s\" does not exist, referenced at node \"%s\"", sInputStr.c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  92.                         return;
  93.                 }
  94.                 UIACTION_WARNING("FG: Invalid object path \"%s\", referenced at node \"%s\"", sInputStr.c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  95.         }
  96.  
  97.         bool UpdateTmplDesc(const string& sInputStr, SActivationInfo* pActInfo)
  98.         {
  99.                 m_pTmplDesc = NULL;
  100.                 if (GetElement())
  101.                 {
  102.                         m_pTmplDesc = GetElement()->GetMovieClipDesc(sInputStr.c_str());
  103.                         if (!m_pTmplDesc)
  104.                         {
  105.                                 UIACTION_WARNING("FG: UIElement \"%s\" does not have template \"%s\", referenced at node \"%s\"", GetElement()->GetName(), sInputStr.c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  106.                                 return false;
  107.                         }
  108.                         return true;
  109.                 }
  110.                 UIACTION_WARNING("FG: Invalid UIElement, referenced at node \"%s\"", pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  111.                 return false;
  112.         }
  113.  
  114.         void Reset()
  115.         {
  116.                 m_pObjectDesc = NULL;
  117.                 m_pTmplDesc = NULL;
  118.         }
  119.  
  120.         inline const typename SUIDescTypeOf<Type>::TType * GetObjectDesc() const { return m_pObjectDesc ? m_pObjectDesc : m_pTmplDesc; }
  121.         inline const SUIMovieClipDesc* GetTmplDesc(bool bNoObjectDescNeeded = false) const { return m_pObjectDesc || bNoObjectDescNeeded ? m_pTmplDesc : NULL; }
  122.  
  123. private:
  124.         template<EUIObjectType ParentType, class Item>
  125.         inline const typename SUIDescTypeOf<Type>::TType * UpdateObjectDescInt(Item * parent, const SUIArguments &path, int depth)
  126.         {
  127.                 if (!parent)
  128.                         return NULL;
  129.  
  130.                 string name;
  131.                 path.GetArg(depth, name);
  132.                 if (depth < path.GetArgCount() - 1)
  133.                         return UpdateObjectDescInt<eUOT_MovieClip>(SUIGetDesc<ParentType, Item, const char*>::GetDesc(parent, name.c_str()), path, depth + 1);
  134.                 return SUIGetDesc<Type, Item, const char*>::GetDesc(parent, name.c_str());
  135.         }
  136.  
  137. private:
  138.         const typename SUIDescTypeOf<Type>::TType * m_pObjectDesc;
  139.         const SUIMovieClipDesc* m_pTmplDesc;
  140. };
  141.  
  142. // ---------------------------------------------------------------
  143. class CFlashUIBaseNodeCategory : public CFlowBaseNode<eNCT_Instanced>
  144. {
  145. public:
  146.         CFlashUIBaseNodeCategory(string sCategory) : m_category(sCategory) {}
  147.  
  148.         const char*          GetCategory() const                { return m_category.c_str(); }
  149.         virtual void         GetMemoryUsage(ICrySizer* s) const { s->Add(*this); }
  150.         virtual void         GetConfiguration(SFlowNodeConfig& config) = 0;
  151.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo) = 0;
  152.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) = 0;
  153.  
  154. private:
  155.         string m_category;
  156. };
  157.  
  158. // ---------------------------------------------------------------
  159. class CFlashUIBaseNodeDynPorts : public CFlashUIBaseNodeCategory
  160. {
  161. public:
  162.         CFlashUIBaseNodeDynPorts(string sCategory) : CFlashUIBaseNodeCategory(sCategory) {}
  163.  
  164. protected:
  165.         void AddParamInputPorts(const SUIEventDesc::SEvtParams& eventDesc, std::vector<SInputPortConfig>& ports);
  166.         void AddParamOutputPorts(const SUIEventDesc::SEvtParams& eventDesc, std::vector<SOutputPortConfig>& ports);
  167.         void AddCheckPorts(const SUIEventDesc::SEvtParams& eventDesc, std::vector<SInputPortConfig>& ports);
  168.  
  169.         void GetDynInput(SUIArguments& args, const SUIParameterDesc& desc, SActivationInfo* pActInfo, int port);
  170.         void ActivateDynOutput(const TUIData& arg, const SUIParameterDesc& desc, SActivationInfo* pActInfo, int port);
  171.  
  172. private:
  173.         string m_enumStr;
  174. };
  175.  
  176. // ---------------------------------------------------------------
  177. class CFlashUIBaseElementNode : public CFlashUIBaseNodeDynPorts
  178. {
  179. public:
  180.         CFlashUIBaseElementNode(IUIElement* pUIElement, string sCategory) : CFlashUIBaseNodeDynPorts(sCategory), m_pElement(pUIElement) { assert(pUIElement); }
  181.         virtual ~CFlashUIBaseElementNode() {};
  182.  
  183.         virtual void GetConfiguration(SFlowNodeConfig& config) = 0;
  184.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo) = 0;
  185.  
  186. protected:
  187.         IUIElement* m_pElement;
  188. };
  189.  
  190. // ---------------------------------------------------------------
  191. // -------------- auto register ui flow node ---------------------
  192. // ---------------------------------------------------------------
  193. class CAutoRegUIFlowNode : public CAutoRegFlowNodeBase
  194. {
  195. public:
  196.         CAutoRegUIFlowNode(const char* sClassName, IFlowNodePtr pFlowNode) : CAutoRegFlowNodeBase(sClassName), m_iRefs(1) { m_pFlowNode = pFlowNode; }
  197.         IFlowNodePtr Create(IFlowNode::SActivationInfo* pActInfo) { return m_pFlowNode->Clone(pActInfo); }
  198.         void         GetMemoryUsage(ICrySizer* s) const           { SIZER_SUBCOMPONENT_NAME(s, "CAutoRegUIFlowNode"); }
  199.         void         Reset()                                      {}
  200.         virtual void AddRef()                                     { m_iRefs++; }
  201.         virtual void Release()                                    { if (--m_iRefs == 0) delete this; }
  202.  
  203. private:
  204.         IFlowNodePtr m_pFlowNode;
  205.         int          m_iRefs;
  206. };
  207.  
  208. // ---------------------------------------------------------------
  209. class CAutoRegUIFlowNodeSingleton : public CAutoRegFlowNodeBase
  210. {
  211. public:
  212.         CAutoRegUIFlowNodeSingleton(const char* sClassName, IFlowNodePtr pFlowNode) : CAutoRegFlowNodeBase(sClassName), m_refs(1) { m_pFlowNode = pFlowNode; }
  213.         IFlowNodePtr Create(IFlowNode::SActivationInfo* pActInfo) { return m_pFlowNode; }
  214.         void         GetMemoryUsage(ICrySizer* s) const           { SIZER_SUBCOMPONENT_NAME(s, "CAutoRegUIFlowNodeSingleton"); }
  215.         virtual void AddRef()                                     { m_refs++; }
  216.         virtual void Release()                                    { if (--m_refs == 0) delete this; }
  217.  
  218. private:
  219.         IFlowNodePtr m_pFlowNode;
  220.         int          m_refs;
  221. };
  222.  
  223. // ---------------------------------------------------------------
  224. // ------------ UI Stack for UI Action nodes ---------------------
  225. // ---------------------------------------------------------------
  226. #ifdef ENABLE_UISTACK_DEBUGGING
  227.         #define UI_STACK_PUSH(stack, val, fmt, ...) stack.push(val, fmt, __VA_ARGS__);
  228. #else
  229.         #define UI_STACK_PUSH(stack, val, fmt, ...) stack.push(val);
  230. #endif
  231.  
  232. class CUIFGStackMan
  233. {
  234. public:
  235.         static int  GetTotalStackSize() { return m_Size; }
  236. #ifdef ENABLE_UISTACK_DEBUGGING
  237.         static void Add(int count, const char* dgbInfo, int id)
  238.         {
  239.                 m_Size += count;
  240.                 for (int i = 0; i < count; ++i)
  241.                         m_debugInfo[id] = dgbInfo;
  242.         }
  243.         static void Remove(int count, int id)
  244.         {
  245.                 m_Size -= count;
  246.                 for (int i = 0; i < count; ++i)
  247.                 {
  248.                         const bool ok = stl::member_find_and_erase(m_debugInfo, id);
  249.                         assert(ok);
  250.                 }
  251.                 assert(m_Size >= 0);
  252.         }
  253.         static const std::map<int, const char*>& GetStack()                { return m_debugInfo; }
  254.         static int                               GetNextId()               { static int id = 0; return id++; }
  255. #else
  256.         static void                              Add(int count = 1)        { m_Size += count; }
  257.         static void                              Remove(int count = 1)     { m_Size -= count; assert(m_Size >= 0); }
  258. #endif
  259.         static bool                              IsEnabled()               { return m_bEnabled; }
  260.         static void                              SetEnabled(bool bEnabled) { m_bEnabled = bEnabled; }
  261.  
  262. private:
  263.         static int                        m_Size;
  264.         static bool                       m_bEnabled;
  265. #ifdef ENABLE_UISTACK_DEBUGGING
  266.         static std::map<int, const char*> m_debugInfo;
  267. #endif
  268. };
  269.  
  270. // ---------------------------------------------------------------
  271. template<class T>
  272. class CUIStack
  273. {
  274. public:
  275.         CUIStack()
  276.                 : m_isUIAction(-1)
  277.                 , m_pGraph(nullptr)
  278.                 , m_pAction(nullptr)
  279.         {}
  280.  
  281.         inline void init(IFlowGraph* pGraph) { InitInt(pGraph); }
  282. #ifdef ENABLE_UISTACK_DEBUGGING
  283.         inline void push(const T& val, const char* fmt, ...)
  284.         {
  285.                 if (gEnv->IsEditor() && !CUIFGStackMan::IsEnabled())
  286.                         return;
  287.                 if (!m_pGraph || !m_pGraph->IsEnabled())
  288.                         return;
  289.  
  290.                 va_list args;
  291.                 va_start(args, fmt);
  292.                 char tmp[1024];
  293.                 cry_vsprintf(tmp, fmt, args);
  294.                 va_end(args);
  295.  
  296.                 m_Impl.push_front(val);
  297.                 if (IsUIAction())
  298.                 {
  299.                         int id = CUIFGStackMan::GetNextId();
  300.                         m_debugInfo.push_back(std::make_pair(tmp, id));
  301.                         CUIFGStackMan::Add(1, m_debugInfo.rbegin()->first.c_str(), id);
  302.                 }
  303.                 CRY_ASSERT_MESSAGE(size() < 256, "Too many items on stack!");
  304.         }
  305.  
  306.         inline void pop()
  307.         {
  308.                 m_Impl.pop_back();
  309.                 if (IsUIAction())
  310.                 {
  311.                         CUIFGStackMan::Remove(1, m_debugInfo.rbegin()->second);
  312.                         m_debugInfo.pop_back();
  313.                 }
  314.         }
  315.  
  316.         inline void clear()
  317.         {
  318.                 while (!m_Impl.empty())
  319.                         pop();
  320.         }
  321.  
  322. #else
  323.         inline void push(const T& val)
  324.         {
  325.                 if (gEnv->IsEditor() && !CUIFGStackMan::IsEnabled())
  326.                         return;
  327.                 if (!m_pGraph || !m_pGraph->IsEnabled())
  328.                         return;
  329.                 m_Impl.push_front(val);
  330.                 if (IsUIAction())
  331.                         CUIFGStackMan::Add();
  332.                 CRY_ASSERT_MESSAGE(size() < 256, "Too many items on stack!");
  333.         }
  334.  
  335.         inline void pop()   { m_Impl.pop_back(); if (IsUIAction()) CUIFGStackMan::Remove(); }
  336.         inline void clear() { if (!m_Impl.empty() && IsUIAction()) CUIFGStackMan::Remove(size()); m_Impl.clear(); }
  337. #endif
  338.  
  339.         inline int      size() const { return m_Impl.size(); }
  340.         inline const T& get() const  { return *m_Impl.rbegin(); }
  341.  
  342. private:
  343.         inline void InitInt(IFlowGraph* pGraph)
  344.         {
  345.                 m_pGraph = pGraph;
  346.                 int i = 0;
  347.                 while (const IUIAction* pAction = gEnv->pFlashUI->GetUIAction(i++))
  348.                 {
  349.                         if (pAction->GetType() == IUIAction::eUIAT_FlowGraph && pAction->GetFlowGraph().get() == pGraph)
  350.                         {
  351.                                 m_pAction = pAction;
  352.                                 m_isUIAction = 1;
  353.                                 return;
  354.                         }
  355.                 }
  356.                 m_isUIAction = 0;
  357.         }
  358.  
  359.         inline bool IsUIAction() const
  360.         {
  361.                 CRY_ASSERT_MESSAGE(m_isUIAction != -1, "Stack was not intialized");
  362.                 return m_isUIAction == 1 && m_pAction->IsEnabled();
  363.         };
  364.  
  365. private:
  366.         std::deque<T>                     m_Impl;
  367. #ifdef ENABLE_UISTACK_DEBUGGING
  368.         std::list<std::pair<string, int>> m_debugInfo;
  369. #endif
  370.         int                               m_isUIAction;
  371.         IFlowGraph*                       m_pGraph;
  372.         const IUIAction*                  m_pAction;
  373. };
  374.  
downloadFlashUIBaseNode.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