BVB Source Codes

CRYENGINE Show FlowMouseInfo.cpp Source code

Return Download CRYENGINE: download FlowMouseInfo.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   FlowMouseInfo.cpp
  5. //  Version:     v1.00
  6. //  Created:     08/26/2013 - Sascha Hoba
  7. //  Description: Mouse Info Flownode
  8. // -------------------------------------------------------------------------
  9. //  History:
  10. //
  11. ////////////////////////////////////////////////////////////////////////////
  12.  
  13. #include "StdAfx.h"
  14.  
  15. #include <CryInput/IHardwareMouse.h>
  16. #include <CryFlowGraph/IFlowBaseNode.h>
  17.  
  18. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  19. class CFlowMouseCoordNode : public CFlowBaseNode<eNCT_Instanced>, public IHardwareMouseEventListener, public IInputEventListener
  20. {
  21. private:
  22.         SActivationInfo m_actInfo;
  23.         bool            m_bOutputWorldCoords;
  24.         bool            m_bOutputScreenCoords;
  25.         bool            m_bOutputDeltaCoords;
  26.         bool            m_enabled;
  27.  
  28. public:
  29.  
  30.         ~CFlowMouseCoordNode()
  31.         {
  32.                 if (gEnv->pHardwareMouse)
  33.                         gEnv->pHardwareMouse->RemoveListener(this);
  34.  
  35.                 if (GetISystem() && GetISystem()->GetIInput())
  36.                         GetISystem()->GetIInput()->RemoveEventListener(this);
  37.         }
  38.  
  39.         CFlowMouseCoordNode(SActivationInfo* pActInfo)
  40.         {
  41.                 m_actInfo = *pActInfo;
  42.                 m_bOutputWorldCoords = false;
  43.                 m_bOutputScreenCoords = false;
  44.                 m_bOutputDeltaCoords = false;
  45.                 m_enabled = false;
  46.         }
  47.  
  48.         enum EInputPorts
  49.         {
  50.                 EIP_Enable = 0,
  51.                 EIP_Disable,
  52.                 EIP_World,
  53.                 EIP_Screen,
  54.                 EIP_DeltaScreen,
  55.         };
  56.  
  57.         enum EOutputPorts
  58.         {
  59.                 EOP_World = 0,
  60.                 EOP_ScreenX,
  61.                 EOP_ScreenY,
  62.                 EOP_DeltaScreenX,
  63.                 EOP_DeltaScreenY,
  64.         };
  65.  
  66.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  67.         {
  68.                 ser.Value("enabled", m_enabled);
  69.  
  70.                 // register listeners if this node was saved as enabled
  71.                 if (ser.IsReading() && m_enabled)
  72.                 {
  73.                         if (gEnv->pHardwareMouse)
  74.                                 gEnv->pHardwareMouse->AddListener(this);
  75.  
  76.                         if (GetISystem() && GetISystem()->GetIInput())
  77.                                 GetISystem()->GetIInput()->AddEventListener(this);
  78.                 }
  79.         }
  80.  
  81.         virtual void GetMemoryUsage(ICrySizer* s) const
  82.         {
  83.                 s->Add(*this);
  84.         }
  85.  
  86.         virtual void GetConfiguration(SFlowNodeConfig& config)
  87.         {
  88.                 static const SInputPortConfig inputs[] = {
  89.                         InputPortConfig_Void("Enable",  _HELP("Enable mouse coord info")),
  90.                         InputPortConfig_Void("Disable", _HELP("Disable mouse coord info")),
  91.                         InputPortConfig<bool>("World",  false,                             _HELP("Output the world x,y,z")),
  92.                         InputPortConfig<bool>("Screen", false,                             _HELP("Output the screen x y")),
  93.                         InputPortConfig<bool>("Delta",  false,                             _HELP("Output the delta x and y")),
  94.                         { 0 }
  95.                 };
  96.  
  97.                 static const SOutputPortConfig outputs[] =
  98.                 {
  99.                         OutputPortConfig<Vec3>("World",       _HELP("Unprojected mouse pos")),
  100.                         OutputPortConfig<int>("ScreenX",      _HELP("Screen X coord")),
  101.                         OutputPortConfig<int>("ScreenY",      _HELP("Screen Y coord")),
  102.                         OutputPortConfig<int>("DeltaScreenX", _HELP("delta screen X coord")),
  103.                         OutputPortConfig<int>("DeltaScreenY", _HELP("Delta screen Y coord")),
  104.                         { 0 }
  105.                 };
  106.  
  107.                 config.pInputPorts = inputs;
  108.                 config.pOutputPorts = outputs;
  109.                 config.sDescription = _HELP("Returns several mouse information.");
  110.                 config.SetCategory(EFLN_APPROVED);
  111.         }
  112.  
  113.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  114.         {
  115.                 return new CFlowMouseCoordNode(pActInfo);
  116.         }
  117.  
  118.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  119.         {
  120.                 m_actInfo = *pActInfo;
  121.                 switch (event)
  122.                 {
  123.                 case eFE_Initialize:
  124.                         {
  125.                                 m_bOutputScreenCoords = GetPortBool(pActInfo, EIP_Screen);
  126.                                 m_bOutputWorldCoords = GetPortBool(pActInfo, EIP_World);
  127.                                 m_bOutputDeltaCoords = GetPortBool(pActInfo, EIP_DeltaScreen);
  128.  
  129.                                 break;
  130.                         }
  131.                 case eFE_Activate:
  132.                         {
  133.                                 if (IsPortActive(pActInfo, EIP_Enable))
  134.                                 {
  135.                                         if (gEnv->pHardwareMouse)
  136.                                                 gEnv->pHardwareMouse->AddListener(this);
  137.  
  138.                                         if (GetISystem() && GetISystem()->GetIInput())
  139.                                                 GetISystem()->GetIInput()->AddEventListener(this);
  140.  
  141.                                         m_bOutputScreenCoords = GetPortBool(pActInfo, EIP_Screen);
  142.                                         m_bOutputWorldCoords = GetPortBool(pActInfo, EIP_World);
  143.                                         m_bOutputDeltaCoords = GetPortBool(pActInfo, EIP_DeltaScreen);
  144.  
  145.                                         m_enabled = true;
  146.                                 }
  147.  
  148.                                 if (IsPortActive(pActInfo, EIP_Disable))
  149.                                 {
  150.                                         if (gEnv->pHardwareMouse)
  151.                                                 gEnv->pHardwareMouse->RemoveListener(this);
  152.  
  153.                                         if (GetISystem() && GetISystem()->GetIInput())
  154.                                                 GetISystem()->GetIInput()->RemoveEventListener(this);
  155.  
  156.                                         m_enabled = false;
  157.                                 }
  158.  
  159.                                 if (IsPortActive(pActInfo, EIP_World))
  160.                                 {
  161.                                         m_bOutputWorldCoords = GetPortBool(pActInfo, EIP_World);
  162.                                 }
  163.  
  164.                                 if (IsPortActive(pActInfo, EIP_Screen))
  165.                                 {
  166.                                         m_bOutputScreenCoords = GetPortBool(pActInfo, EIP_Screen);
  167.                                 }
  168.  
  169.                                 if (IsPortActive(pActInfo, EIP_DeltaScreen))
  170.                                 {
  171.                                         m_bOutputDeltaCoords = GetPortBool(pActInfo, EIP_DeltaScreen);
  172.                                 }
  173.  
  174.                                 break;
  175.                         }
  176.                 }
  177.         }
  178.  
  179.         virtual void OnHardwareMouseEvent(int iX, int iY, EHARDWAREMOUSEEVENT eHardwareMouseEvent, int wheelDelta = 0)
  180.         {
  181.                 if (m_bOutputScreenCoords)
  182.                 {
  183.                         ActivateOutput(&m_actInfo, EOP_ScreenX, iX);
  184.                         ActivateOutput(&m_actInfo, EOP_ScreenY, iY);
  185.                 }
  186.  
  187.                 if (m_bOutputWorldCoords)
  188.                 {
  189.                         Vec3 vPos;
  190.                         int mouseX, mouseY;
  191.                         mouseX = iX;
  192.                         mouseY = gEnv->pRenderer->GetHeight() - iY;
  193.                         gEnv->pRenderer->UnProjectFromScreen((float)mouseX, (float)mouseY, 1, &vPos.x, &vPos.y, &vPos.z);
  194.  
  195.                         ActivateOutput(&m_actInfo, EOP_World, vPos);
  196.                 }
  197.         }
  198.  
  199.         virtual bool OnInputEvent(const SInputEvent& event)
  200.         {
  201.                 if (m_bOutputDeltaCoords == false)
  202.                         return false;
  203.  
  204.                 switch (event.keyId)
  205.                 {
  206.                 case eKI_MouseX:
  207.                         {
  208.                                 ActivateOutput(&m_actInfo, EOP_DeltaScreenX, event.value);
  209.                                 break;
  210.                         }
  211.                 case eKI_MouseY:
  212.                         {
  213.                                 ActivateOutput(&m_actInfo, EOP_DeltaScreenY, event.value);
  214.                                 break;
  215.                         }
  216.                 }
  217.  
  218.                 return false;
  219.         }
  220.  
  221. };
  222.  
  223. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  224. class CFlowMouseButtonNode : public CFlowBaseNode<eNCT_Instanced>, public IInputEventListener
  225. {
  226. private:
  227.         SActivationInfo m_actInfo;
  228.         bool            m_bOutputMouseButton;
  229.         bool            m_bOutputMouseWheel;
  230.         bool            m_enabled;
  231.  
  232. public:
  233.  
  234.         CFlowMouseButtonNode(SActivationInfo* pActInfo)
  235.         {
  236.                 m_actInfo = *pActInfo;
  237.                 m_bOutputMouseButton = false;
  238.                 m_bOutputMouseWheel = false;
  239.                 m_enabled = false;
  240.         }
  241.  
  242.         ~CFlowMouseButtonNode()
  243.         {
  244.                 if (GetISystem() && GetISystem()->GetIInput())
  245.                         GetISystem()->GetIInput()->RemoveEventListener(this);
  246.         }
  247.  
  248.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  249.         {
  250.                 ser.Value("enabled", m_enabled);
  251.  
  252.                 // register listeners if this node was saved as enabled
  253.                 if (ser.IsReading() && m_enabled)
  254.                 {
  255.                         if (GetISystem() && GetISystem()->GetIInput())
  256.                                 GetISystem()->GetIInput()->AddEventListener(this);
  257.                 }
  258.         }
  259.  
  260.         enum EInputPorts
  261.         {
  262.                 EIP_Enable = 0,
  263.                 EIP_Disable,
  264.                 EIP_OuputMouseButtons,
  265.                 EIP_OuputMouseWheel,
  266.         };
  267.  
  268.         enum EOutputPorts
  269.         {
  270.                 EOP_MousePressed = 0,
  271.                 EOP_MouseReleased,
  272.                 EOP_MouseWheel
  273.         };
  274.  
  275.         virtual void GetMemoryUsage(ICrySizer* s) const
  276.         {
  277.                 s->Add(*this);
  278.         }
  279.  
  280.         virtual void GetConfiguration(SFlowNodeConfig& config)
  281.         {
  282.                 static const SInputPortConfig inputs[] = {
  283.                         InputPortConfig_Void("Enable",       _HELP("Enable mouse button info")),
  284.                         InputPortConfig_Void("Disable",      _HELP("Disable mouse button info")),
  285.                         InputPortConfig<bool>("MouseButton", false,                              _HELP("Output the mouse button info")),
  286.                         InputPortConfig<bool>("MouseWheel",  false,                              _HELP("Output the mouse wheel info")),
  287.                         { 0 }
  288.                 };
  289.  
  290.                 static const SOutputPortConfig outputs[] =
  291.                 {
  292.                         OutputPortConfig<int>("MousePressed",  _HELP("The int represents the mouse button that was pressed")),
  293.                         OutputPortConfig<int>("MouseReleased", _HELP("The int represents the mouse button that was released")),
  294.                         OutputPortConfig<float>("MouseWheel",  _HELP("Positive is wheel up, negative is wheel down")),
  295.                         { 0 }
  296.                 };
  297.  
  298.                 config.pInputPorts = inputs;
  299.                 config.pOutputPorts = outputs;
  300.                 config.sDescription = _HELP("Mouse button information");
  301.                 config.SetCategory(EFLN_APPROVED);
  302.         }
  303.  
  304.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  305.         {
  306.                 return new CFlowMouseButtonNode(pActInfo);
  307.         }
  308.  
  309.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  310.         {
  311.                 m_actInfo = *pActInfo;
  312.                 switch (event)
  313.                 {
  314.                 case eFE_Initialize:
  315.                         {
  316.                                 m_bOutputMouseButton = GetPortBool(pActInfo, EIP_OuputMouseButtons);
  317.                                 m_bOutputMouseWheel = GetPortBool(pActInfo, EIP_OuputMouseWheel);
  318.  
  319.                                 break;
  320.                         }
  321.                 case eFE_Activate:
  322.                         {
  323.                                 if (IsPortActive(pActInfo, EIP_Enable))
  324.                                 {
  325.                                         if (GetISystem() && GetISystem()->GetIInput())
  326.                                                 GetISystem()->GetIInput()->AddEventListener(this);
  327.  
  328.                                         m_bOutputMouseButton = GetPortBool(pActInfo, EIP_OuputMouseButtons);
  329.                                         m_bOutputMouseWheel = GetPortBool(pActInfo, EIP_OuputMouseWheel);
  330.  
  331.                                         m_enabled = true;
  332.                                 }
  333.  
  334.                                 if (IsPortActive(pActInfo, EIP_Disable))
  335.                                 {
  336.                                         if (GetISystem() && GetISystem()->GetIInput())
  337.                                                 GetISystem()->GetIInput()->RemoveEventListener(this);
  338.  
  339.                                         m_enabled = false;
  340.                                 }
  341.  
  342.                                 if (IsPortActive(pActInfo, EIP_OuputMouseButtons))
  343.                                 {
  344.                                         m_bOutputMouseButton = GetPortBool(pActInfo, EIP_OuputMouseButtons);
  345.                                 }
  346.  
  347.                                 if (IsPortActive(pActInfo, EIP_OuputMouseWheel))
  348.                                 {
  349.                                         m_bOutputMouseWheel = GetPortBool(pActInfo, EIP_OuputMouseWheel);
  350.                                 }
  351.  
  352.                                 break;
  353.                         }
  354.                 }
  355.         }
  356.  
  357.         virtual bool OnInputEvent(const SInputEvent& event)
  358.         {
  359.                 switch (event.keyId)
  360.                 {
  361.                 case eKI_Mouse1:
  362.                 case eKI_Mouse2:
  363.                 case eKI_Mouse3:
  364.                 case eKI_Mouse4:
  365.                 case eKI_Mouse5:
  366.                 case eKI_Mouse6:
  367.                 case eKI_Mouse7:
  368.                 case eKI_Mouse8:
  369.                         if (m_bOutputMouseButton)
  370.                         {
  371.                                 if (event.state == eIS_Pressed)
  372.                                 {
  373.                                         ActivateOutput(&m_actInfo, EOP_MousePressed, (event.keyId - KI_MOUSE_BASE) + 1); // mouse1 should be 1, etc
  374.                                 }
  375.                                 if (event.state == eIS_Released)
  376.                                 {
  377.                                         ActivateOutput(&m_actInfo, EOP_MouseReleased, (event.keyId - KI_MOUSE_BASE) + 1); // mouse1 should be 1, etc
  378.                                 }
  379.                         }
  380.                         break;
  381.                 case eKI_MouseWheelDown:
  382.                 case eKI_MouseWheelUp:
  383.                         // pressed: started scrolling, down: repeating event while scrolling at a speed, released: finished (delta 0)
  384.                         // for every pressed event there is at least 1 down event, and we only want to forward the down event to the user (shows the speed and length of a scroll)
  385.                         if (m_bOutputMouseWheel && event.state == eIS_Down)
  386.                         {
  387.                                 ActivateOutput(&m_actInfo, EOP_MouseWheel, event.value);
  388.                         }
  389.                         break;
  390.                 }
  391.  
  392.                 return false;
  393.         }
  394.  
  395. };
  396.  
  397. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  398. class CFlowMouseRayCast : public CFlowBaseNode<eNCT_Instanced>, public IHardwareMouseEventListener, public IGameFrameworkListener
  399. {
  400. private:
  401.         SActivationInfo    m_actInfo;
  402.         int                m_mouseX, m_mouseY;
  403.         entity_query_flags m_rayTypeFilter;
  404.         bool               m_enabled;
  405.  
  406. public:
  407.  
  408.         CFlowMouseRayCast(SActivationInfo* pActInfo)
  409.         {
  410.                 m_actInfo = *pActInfo;
  411.                 m_mouseX = 0;
  412.                 m_mouseY = 0;
  413.                 m_rayTypeFilter = ent_all;
  414.                 m_enabled = false;
  415.         }
  416.  
  417.         ~CFlowMouseRayCast()
  418.         {
  419.                 if (gEnv->pHardwareMouse)
  420.                         gEnv->pHardwareMouse->RemoveListener(this);
  421.  
  422.                 if (gEnv->pGameFramework)
  423.                         gEnv->pGameFramework->UnregisterListener(this);
  424.         }
  425.  
  426.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  427.         {
  428.                 ser.Value("enabled", m_enabled);
  429.  
  430.                 // register listeners if this node was saved as enabled
  431.                 if (ser.IsReading() && m_enabled)
  432.                 {
  433.                         if (gEnv->pHardwareMouse)
  434.                                 gEnv->pHardwareMouse->AddListener(this);
  435.  
  436.                         if (gEnv->pGameFramework)
  437.                                 gEnv->pGameFramework->RegisterListener(this, "MouseRayInfoNode", FRAMEWORKLISTENERPRIORITY_DEFAULT);
  438.                 }
  439.         }
  440.  
  441.         enum EInputPorts
  442.         {
  443.                 EIP_Enable = 0,
  444.                 EIP_Disable,
  445.                 EIP_RayType,
  446.                 EIP_EntitiesToIgnore,
  447.         };
  448.  
  449.         enum EOutputPorts
  450.         {
  451.                 EOP_HitPos = 0,
  452.                 EOP_HitNormal,
  453.                 EOP_EntityId,
  454.         };
  455.  
  456.         virtual void GetMemoryUsage(ICrySizer* s) const
  457.         {
  458.                 s->Add(*this);
  459.         }
  460.  
  461.         virtual void GetConfiguration(SFlowNodeConfig& config)
  462.         {
  463.                 static const SInputPortConfig inputs[] = {
  464.                         InputPortConfig_Void("Enable",           _HELP("Enable mouse button info")),
  465.                         InputPortConfig_Void("Disable",          _HELP("Disable mouse button info")),
  466.                         InputPortConfig<int>("RayType",          0,                                                         _HELP("What should cause a ray hit?"),"All", _UICONFIG("enum_int: All=0, Terrain=1, Rigid=2, Static=3, Water=4, Living=5")),
  467.                         InputPortConfig<int>("EntitiesToIgnore", _HELP("Container with Entities to ignore during raycast")),
  468.                         { 0 }
  469.                 };
  470.  
  471.                 static const SOutputPortConfig outputs[] =
  472.                 {
  473.                         OutputPortConfig<Vec3>("HitPos",       _HELP("The int represents the mouse button that was pressed")),
  474.                         OutputPortConfig<Vec3>("HitNormal",    _HELP("The int represents the mouse button that was released")),
  475.                         OutputPortConfig<EntityId>("EntityId", _HELP("Entity that got hit by raycast")),
  476.                         { 0 }
  477.                 };
  478.  
  479.                 config.pInputPorts = inputs;
  480.                 config.pOutputPorts = outputs;
  481.                 config.sDescription = _HELP("Mouse ray information");
  482.                 config.SetCategory(EFLN_APPROVED);
  483.         }
  484.  
  485.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  486.         {
  487.                 return new CFlowMouseRayCast(pActInfo);
  488.         }
  489.  
  490.         void StoreRayType()
  491.         {
  492.                 int ray_type = GetPortInt(&m_actInfo, EIP_RayType);
  493.                 switch (ray_type)
  494.                 {
  495.                 case 0:
  496.                         m_rayTypeFilter = ent_all;
  497.                         break;
  498.                 case 1:
  499.                         m_rayTypeFilter = ent_terrain;
  500.                         break;
  501.                 case 2:
  502.                         m_rayTypeFilter = ent_rigid;
  503.                         break;
  504.                 case 3:
  505.                         m_rayTypeFilter = ent_static;
  506.                         break;
  507.                 case 4:
  508.                         m_rayTypeFilter = ent_water;
  509.                         break;
  510.                 case 5:
  511.                         m_rayTypeFilter = ent_living;
  512.                         break;
  513.                 }
  514.         }
  515.  
  516.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  517.         {
  518.                 m_actInfo = *pActInfo;
  519.                 switch (event)
  520.                 {
  521.                 case eFE_Initialize:
  522.                         {
  523.                                 StoreRayType();
  524.                         }
  525.                         break;
  526.                 case eFE_Activate:
  527.                         {
  528.                                 if (IsPortActive(pActInfo, EIP_Enable))
  529.                                 {
  530.                                         if (gEnv->pHardwareMouse)
  531.                                                 gEnv->pHardwareMouse->AddListener(this);
  532.  
  533.                                         if (gEnv->pGameFramework)
  534.                                                 gEnv->pGameFramework->RegisterListener(this, "MouseRayInfoNode", FRAMEWORKLISTENERPRIORITY_DEFAULT);
  535.  
  536.                                         StoreRayType();
  537.                                         m_enabled = true;
  538.                                 }
  539.  
  540.                                 if (IsPortActive(pActInfo, EIP_Disable))
  541.                                 {
  542.                                         if (gEnv->pHardwareMouse)
  543.                                                 gEnv->pHardwareMouse->RemoveListener(this);
  544.  
  545.                                         if (gEnv->pGameFramework)
  546.                                                 gEnv->pGameFramework->UnregisterListener(this);
  547.  
  548.                                         m_enabled = false;
  549.                                 }
  550.  
  551.                                 if (IsPortActive(pActInfo, EIP_RayType))
  552.                                 {
  553.                                         StoreRayType();
  554.                                 }
  555.  
  556.                                 break;
  557.                         }
  558.                 }
  559.         }
  560.  
  561.         // IHardwareMouseEventListener
  562.         virtual void OnHardwareMouseEvent(int iX, int iY, EHARDWAREMOUSEEVENT eHardwareMouseEvent, int wheelDelta = 0)
  563.         {
  564.                 m_mouseX = iX;
  565.                 m_mouseY = iY;
  566.         }
  567.         // ~IHardwareMouseEventListener
  568.  
  569.         // IGameFrameworkListener
  570.         virtual void OnSaveGame(ISaveGame* pSaveGame)         {}
  571.         virtual void OnLoadGame(ILoadGame* pLoadGame)         {}
  572.         virtual void OnLevelEnd(const char* nextLevel)        {}
  573.         virtual void OnActionEvent(const SActionEvent& event) {}
  574.  
  575.         // Since the modelviewmatrix is updated in the update, and flowgraph is updated in the preupdate, we need this postupdate
  576.         virtual void OnPostUpdate(float fDeltaTime)
  577.         {
  578.                 int invMouseY = gEnv->pRenderer->GetHeight() - m_mouseY;
  579.  
  580.                 Vec3 vPos0(0, 0, 0);
  581.                 gEnv->pRenderer->UnProjectFromScreen((float)m_mouseX, (float)invMouseY, 0, &vPos0.x, &vPos0.y, &vPos0.z);
  582.  
  583.                 Vec3 vPos1(0, 0, 0);
  584.                 gEnv->pRenderer->UnProjectFromScreen((float)m_mouseX, (float)invMouseY, 1, &vPos1.x, &vPos1.y, &vPos1.z);
  585.  
  586.                 Vec3 vDir = vPos1 - vPos0;
  587.                 vDir.Normalize();
  588.  
  589.                 ray_hit hit;
  590.                 const unsigned int flags = rwi_stop_at_pierceable | rwi_colltype_any;
  591.  
  592.                 IPhysicalEntity** pSkipEnts = NULL;
  593.                 int numSkipped = 0;
  594.  
  595.                 int containerId = GetPortInt(&m_actInfo, EIP_EntitiesToIgnore);
  596.                 if (containerId != 0)
  597.                 {
  598.                         IFlowSystemContainerPtr container = gEnv->pFlowSystem->GetContainer(containerId);
  599.                         numSkipped = container->GetItemCount();
  600.                         pSkipEnts = new IPhysicalEntity*[numSkipped];
  601.                         for (int i = 0; i < numSkipped; i++)
  602.                         {
  603.                                 EntityId id;
  604.                                 container->GetItem(i).GetValueWithConversion(id);
  605.                                 pSkipEnts[i] = gEnv->pEntitySystem->GetEntity(id)->GetPhysics();
  606.                         }
  607.                 }
  608.  
  609.                 if (gEnv->pPhysicalWorld && gEnv->pPhysicalWorld->RayWorldIntersection(vPos0, vDir * gEnv->p3DEngine->GetMaxViewDistance(), m_rayTypeFilter, flags, &hit, 1, pSkipEnts, numSkipped))
  610.                 {
  611.                         ActivateOutput(&m_actInfo, EOP_HitPos, hit.pt);
  612.                         ActivateOutput(&m_actInfo, EOP_HitNormal, hit.n);
  613.  
  614.                         if (hit.pCollider)
  615.                         {
  616.                                 if (IEntity* pEntity = gEnv->pEntitySystem->GetEntityFromPhysics(hit.pCollider))
  617.                                 {
  618.                                         ActivateOutput(&m_actInfo, EOP_EntityId, pEntity->GetId());
  619.                                 }
  620.                         }
  621.                 }
  622.  
  623.                 if (pSkipEnts)
  624.                         delete[] pSkipEnts;
  625.         }
  626.         // ~IGameFrameworkListener
  627. };
  628.  
  629. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  630. class CFlowMouseCursor : public CFlowBaseNode<eNCT_Instanced>
  631. {
  632. private:
  633.         bool m_isShowing;
  634.  
  635. public:
  636.  
  637.         CFlowMouseCursor(SActivationInfo* pActInfo)
  638.         {
  639.                 m_isShowing = false;
  640.         }
  641.  
  642.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  643.         {
  644.                 ser.Value("isShowing", m_isShowing);
  645.  
  646.                 if (ser.IsReading())
  647.                 {
  648.                         if (m_isShowing)
  649.                         {
  650.                                 gEnv->pHardwareMouse->IncrementCounter();
  651.                         }
  652.                 }
  653.         }
  654.  
  655.         ~CFlowMouseCursor()
  656.         {
  657.                 // make sure to put the cursor at the correct counter before deleting this
  658.                 if (m_isShowing)
  659.                 {
  660.                         gEnv->pHardwareMouse->DecrementCounter();
  661.                 }
  662.         }
  663.  
  664.         enum EInputPorts
  665.         {
  666.                 EIP_Show = 0,
  667.                 EIP_Hide,
  668.         };
  669.  
  670.         enum EOutputPorts
  671.         {
  672.                 EOP_Done = 0,
  673.         };
  674.  
  675.         virtual void GetMemoryUsage(ICrySizer* s) const
  676.         {
  677.                 s->Add(*this);
  678.         }
  679.  
  680.         virtual void GetConfiguration(SFlowNodeConfig& config)
  681.         {
  682.                 static const SInputPortConfig inputs[] = {
  683.                         InputPortConfig_Void("Show", _HELP("Show mouse cursor")),
  684.                         InputPortConfig_Void("Hide", _HELP("Hide the mouse cursor")),
  685.                         { 0 }
  686.                 };
  687.  
  688.                 static const SOutputPortConfig outputs[] =
  689.                 {
  690.                         OutputPortConfig_Void("Done", _HELP("Done")),
  691.                         { 0 }
  692.                 };
  693.  
  694.                 config.pInputPorts = inputs;
  695.                 config.pOutputPorts = outputs;
  696.                 config.sDescription = _HELP("Node to show or hide the mouse cursor");
  697.                 config.SetCategory(EFLN_APPROVED);
  698.         }
  699.  
  700.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  701.         {
  702.                 return new CFlowMouseCursor(pActInfo);
  703.         }
  704.  
  705.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  706.         {
  707.                 switch (event)
  708.                 {
  709.                 case eFE_Initialize:
  710.                         {
  711.                                 // hide cursor from start (default behavior)
  712.                                 if (m_isShowing)
  713.                                 {
  714.                                         gEnv->pHardwareMouse->DecrementCounter();
  715.                                         m_isShowing = false;
  716.                                 }
  717.                         }
  718.                         break;
  719.                 case eFE_Activate:
  720.                         {
  721.                                 if (IsPortActive(pActInfo, EIP_Show))
  722.                                 {
  723.                                         if (!m_isShowing)
  724.                                         {
  725.                                                 gEnv->pHardwareMouse->IncrementCounter();
  726.                                                 m_isShowing = true;
  727.                                         }
  728.  
  729.                                         ActivateOutput(pActInfo, EOP_Done, 1);
  730.                                 }
  731.  
  732.                                 if (IsPortActive(pActInfo, EIP_Hide))
  733.                                 {
  734.                                         if (m_isShowing)
  735.                                         {
  736.                                                 gEnv->pHardwareMouse->DecrementCounter();
  737.                                                 m_isShowing = false;
  738.                                         }
  739.  
  740.                                         ActivateOutput(pActInfo, EOP_Done, 1);
  741.                                 }
  742.  
  743.                                 break;
  744.                         }
  745.                 }
  746.         }
  747.  
  748. };
  749.  
  750. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  751. class CFlowMouseEntitiesInBox : public CFlowBaseNode<eNCT_Instanced>, public IGameFrameworkListener
  752. {
  753. private:
  754.         int             m_screenX, m_screenY, m_screenX2, m_screenY2;
  755.         SActivationInfo m_actInfo;
  756.         bool            m_get;
  757.  
  758. public:
  759.  
  760.         CFlowMouseEntitiesInBox(SActivationInfo* pActInfo)
  761.         {
  762.                 m_screenX = 0;
  763.                 m_screenX2 = 0;
  764.                 m_screenY = 0;
  765.                 m_screenY2 = 0;
  766.                 m_get = false;
  767.         }
  768.  
  769.         ~CFlowMouseEntitiesInBox()
  770.         {
  771.                 if (gEnv->pGameFramework)
  772.                         gEnv->pGameFramework->UnregisterListener(this);
  773.         }
  774.  
  775.         enum EInputPorts
  776.         {
  777.                 EIP_Get = 0,
  778.                 EIP_ContainerId,
  779.                 EIP_ScreenX,
  780.                 EIP_ScreenY,
  781.                 EIP_ScreenX2,
  782.                 EIP_ScreenY2,
  783.         };
  784.  
  785.         enum EOutputPorts
  786.         {
  787.                 EOP_Done = 0,
  788.         };
  789.  
  790.         virtual void GetMemoryUsage(ICrySizer* s) const
  791.         {
  792.                 s->Add(*this);
  793.         }
  794.  
  795.         virtual void GetConfiguration(SFlowNodeConfig& config)
  796.         {
  797.                 static const SInputPortConfig inputs[] = {
  798.                         InputPortConfig_Void("Get",         _HELP("Show mouse cursor")),
  799.                         InputPortConfig<int>("ContainerId", _HELP("The container to store the entitieIds in, user is responsible for creating/deleting this")),
  800.                         InputPortConfig<int>("ScreenX",     _HELP("Hide the mouse cursor")),
  801.                         InputPortConfig<int>("ScreenY",     _HELP("Hide the mouse cursor")),
  802.                         InputPortConfig<int>("ScreenX2",    _HELP("Hide the mouse cursor")),
  803.                         InputPortConfig<int>("ScreenY2",    _HELP("Hide the mouse cursor")),
  804.                         { 0 }
  805.                 };
  806.  
  807.                 static const SOutputPortConfig outputs[] =
  808.                 {
  809.                         OutputPortConfig_Void("Done", _HELP("Done")),
  810.                         { 0 }
  811.                 };
  812.  
  813.                 config.pInputPorts = inputs;
  814.                 config.pOutputPorts = outputs;
  815.                 config.sDescription = _HELP("Node to show or hide the mouse cursor");
  816.                 config.SetCategory(EFLN_APPROVED);
  817.         }
  818.  
  819.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  820.         {
  821.                 return new CFlowMouseEntitiesInBox(pActInfo);
  822.         }
  823.  
  824.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  825.         {
  826.                 switch (event)
  827.                 {
  828.                 case eFE_Update:
  829.                         {
  830.  
  831.                         }
  832.                         break;
  833.                 case eFE_Activate:
  834.                         {
  835.                                 if (IsPortActive(pActInfo, EIP_Get))
  836.                                 {
  837.                                         gEnv->pGameFramework->RegisterListener(this, "FlowMouseEntitiesInBox", FRAMEWORKLISTENERPRIORITY_DEFAULT);
  838.  
  839.                                         m_get = true;
  840.                                         m_actInfo = *pActInfo;
  841.                                         m_screenX = GetPortInt(pActInfo, EIP_ScreenX);
  842.                                         m_screenY = GetPortInt(pActInfo, EIP_ScreenY);
  843.                                         m_screenX2 = GetPortInt(pActInfo, EIP_ScreenX2);
  844.                                         m_screenY2 = GetPortInt(pActInfo, EIP_ScreenY2);
  845.                                 }
  846.                                 break;
  847.                         }
  848.                 }
  849.         }
  850.  
  851.         // IGameFrameworkListener
  852.         virtual void OnSaveGame(ISaveGame* pSaveGame)         {}
  853.         virtual void OnLoadGame(ILoadGame* pLoadGame)         {}
  854.         virtual void OnLevelEnd(const char* nextLevel)        {}
  855.         virtual void OnActionEvent(const SActionEvent& event) {}
  856.         virtual void OnPostUpdate(float fDeltaTime)
  857.         {
  858.                 // Get it once, then unregister to prevent unnescessary updates
  859.                 if (!m_get)
  860.                 {
  861.                         gEnv->pGameFramework->UnregisterListener(this);
  862.                         return;
  863.                 }
  864.                 m_get = false;
  865.  
  866.                 // Grab the container, and make sure its valid (user has to create it for us and pass the valid ID)
  867.                 IFlowSystemContainerPtr pContainer = gEnv->pFlowSystem->GetContainer(GetPortInt(&m_actInfo, EIP_ContainerId));
  868.  
  869.                 if (!pContainer)
  870.                         return;
  871.  
  872.                 IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
  873.  
  874.                 while (!pIt->IsEnd())
  875.                 {
  876.                         if (IEntity* pEntity = pIt->Next())
  877.                         {
  878.                                 //skip Local player
  879.                                 if (IPhysicalEntity* physEnt = pEntity->GetPhysics())
  880.                                 {
  881.                                         IActor* pClientActor = gEnv->pGameFramework->GetClientActor();
  882.  
  883.                                         if (!pClientActor)
  884.                                                 return;
  885.  
  886.                                         //skip the client actor entity
  887.                                         if (physEnt == pClientActor->GetEntity()->GetPhysics())
  888.                                                 continue;
  889.  
  890.                                         AABB worldBounds;
  891.                                         pEntity->GetWorldBounds(worldBounds);
  892.  
  893.                                         //skip further calculations if the entity is not visible at all...
  894.                                         if (gEnv->pSystem->GetViewCamera().IsAABBVisible_F(worldBounds) == CULL_EXCLUSION)
  895.                                                 continue;
  896.  
  897.                                         Vec3 wpos = pEntity->GetWorldPos();
  898.                                         Quat rot = pEntity->GetWorldRotation();
  899.                                         AABB localBounds;
  900.  
  901.                                         pEntity->GetLocalBounds(localBounds);
  902.  
  903.                                         //get min and max values of the entity bounding box (local positions)
  904.                                         Vec3 points[2];
  905.                                         points[0] = wpos + rot * localBounds.min;
  906.                                         points[1] = wpos + rot * localBounds.max;
  907.  
  908.                                         Vec3 pointsProjected[2];
  909.  
  910.                                         //project the bounding box min max values to screen positions
  911.                                         for (int i = 0; i < 2; ++i)
  912.                                         {
  913.                                                 gEnv->pRenderer->ProjectToScreen(points[i].x, points[i].y, points[i].z, &pointsProjected[i].x, &pointsProjected[i].y, &pointsProjected[i].z);
  914.                                                 const float fWidth = (float)gEnv->pRenderer->GetWidth();
  915.                                                 const float fHeight = (float)gEnv->pRenderer->GetHeight();
  916.  
  917.                                                 //scale projected values to the actual screen resolution
  918.                                                 pointsProjected[i].x *= 0.01f * fWidth;
  919.                                                 pointsProjected[i].y *= 0.01f * fHeight;
  920.                                         }
  921.  
  922.                                         //check if the projected bounding box min max values are fully or partly inside the screen selection
  923.                                         if ((m_screenX <= pointsProjected[0].x && pointsProjected[0].x <= m_screenX2) ||
  924.                                             (m_screenX >= pointsProjected[0].x && m_screenX2 <= pointsProjected[1].x) ||
  925.                                             (m_screenX <= pointsProjected[1].x && m_screenX2 >= pointsProjected[1].x) ||
  926.                                             (m_screenX <= pointsProjected[0].x && m_screenX2 >= pointsProjected[1].x))
  927.                                         {
  928.                                                 if ((m_screenY <= pointsProjected[0].y && m_screenY2 >= pointsProjected[0].y) ||
  929.                                                     (m_screenY <= pointsProjected[1].y && m_screenY2 >= pointsProjected[0].y) ||
  930.                                                     (m_screenY <= pointsProjected[1].y && m_screenY2 >= pointsProjected[1].y))
  931.                                                 {
  932.                                                         // Add entity to container
  933.                                                         pContainer->AddItem(TFlowInputData(pEntity->GetId()));
  934.                                                 }
  935.                                         }
  936.                                 }
  937.  
  938.                         }
  939.                 }
  940.         }
  941.         // ~IGameFrameworkListener
  942.  
  943. };
  944.  
  945. REGISTER_FLOW_NODE("Input:MouseCoords", CFlowMouseCoordNode);
  946. REGISTER_FLOW_NODE("Input:MouseButtonInfo", CFlowMouseButtonNode);
  947. REGISTER_FLOW_NODE("Input:MouseRayCast", CFlowMouseRayCast);
  948. REGISTER_FLOW_NODE("Input:MouseCursor", CFlowMouseCursor);
  949. REGISTER_FLOW_NODE("Input:MouseEntitiesInBox", CFlowMouseEntitiesInBox);
  950.  
downloadFlowMouseInfo.cpp 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