BVB Source Codes

CRYENGINE Show FlowCameraNodes.cpp Source code

Return Download CRYENGINE: download FlowCameraNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "FlowFrameworkBaseNode.h"
  5.  
  6. //////////////////////////////////////////////////////////////////////////
  7. static const int FLOWGRAPH_SHAKE_ID = 24;
  8.  
  9. //////////////////////////////////////////////////////////////////////////
  10. class CFlowNode_CameraViewShakeEx : public CFlowBaseNode<eNCT_Instanced>
  11. {
  12. public:
  13.         CFlowNode_CameraViewShakeEx(SActivationInfo* pActInfo)
  14.                 : m_lastShakeFrameID(0)
  15.         {
  16.         };
  17.  
  18.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_CameraViewShakeEx(pActInfo); }
  19.  
  20.         enum eRestriction
  21.         {
  22.                 ER_None = 0,
  23.                 ER_NoVehicle,
  24.                 ER_InVehicle,
  25.         };
  26.  
  27.         enum eInputs
  28.         {
  29.                 EIP_Trigger = 0,
  30.                 EIP_Restriction,
  31.                 EIP_ViewType,
  32.                 EIP_GroundOnly,
  33.                 EIP_Smooth,
  34.                 EIP_Angle,
  35.                 EIP_Shift,
  36.                 EIP_Frequency,
  37.                 EIP_Randomness,
  38.                 EIP_Distance,
  39.                 EIP_RangeMin,
  40.                 EIP_RangeMax,
  41.                 EIP_SustainDuration,
  42.                 EIP_FadeInDuration,
  43.                 EIP_FadeOutDuration,
  44.                 EIP_Stop,
  45.                 EIP_Preset,
  46.                 // EIP_Flip,
  47.         };
  48.  
  49.         enum eViewType
  50.         {
  51.                 VT_FirstPerson = 0,
  52.                 VT_Current     = 1
  53.         };
  54.  
  55.         enum { NUM_PRESETS = 4 };
  56.  
  57.         struct SInputParams
  58.         {
  59.                 const char*  pName;
  60.                 eRestriction restriction;
  61.                 eViewType    view;
  62.                 bool         groundOnly;
  63.                 bool         isSmooth;
  64.                 Ang3         angle;
  65.                 Vec3         shift;
  66.                 float        frequency;
  67.                 float        randomness;
  68.                 float        distance;
  69.                 float        rangeMin;
  70.                 float        rangeMax;
  71.                 float        sustainDuration;
  72.                 float        fadeInDuration;
  73.                 float        fadeOutDuration;
  74.         };
  75.  
  76.         virtual void GetMemoryUsage(ICrySizer* s) const
  77.         {
  78.                 s->Add(*this);
  79.         }
  80.  
  81.         virtual void GetConfiguration(SFlowNodeConfig& config)
  82.         {
  83. #ifndef _RELEASE
  84.                 static char pPresetsHelp[1024] = "";
  85.  
  86.                 if (pPresetsHelp[0] == 0)
  87.                 {
  88.                         cry_strcpy(pPresetsHelp, "Preset input values. When this is used, all parameter inputs are ignored.\n");
  89.                         for (int i = 0; i < NUM_PRESETS; i++)
  90.                         {
  91.                                 char buf[300];
  92.                                 cry_sprintf(buf, "-- %s : Angle: (%4.3f,%4.3f,%4.3f)  Shift: (%4.3f,%4.3f,%4.3f )  Freq: %3.1f  Random: %3.1f  Distance: %3.1f  RangeMin: %3.1f RangeMax: %3.1f sustainDuration: %3.1f FadeInDur: %3.1f  FadeOutDur: %3.1f \n",
  93.                                             m_Presets[i].pName, m_Presets[i].angle.x, m_Presets[i].angle.y, m_Presets[i].angle.z, m_Presets[i].shift.x, m_Presets[i].shift.y, m_Presets[i].shift.z, m_Presets[i].frequency,
  94.                                             m_Presets[i].randomness, m_Presets[i].distance, m_Presets[i].rangeMin, m_Presets[i].rangeMax, m_Presets[i].sustainDuration, m_Presets[i].fadeInDuration, m_Presets[i].fadeOutDuration);
  95.  
  96.                                 cry_strcat(pPresetsHelp, buf);
  97.                         }
  98.                 }
  99.  
  100.                 static char pPresetsEnumDef[100] = "";
  101.                 if (pPresetsEnumDef[0] == 0)
  102.                 {
  103.                         cry_strcpy(pPresetsEnumDef, "enum_int:NoPreset=0,");
  104.                         for (int i = 0; i < NUM_PRESETS; i++)
  105.                         {
  106.                                 char buf[100];
  107.                                 cry_sprintf(buf, "%s=%1d,", m_Presets[i].pName, i + 1);
  108.                                 cry_strcat(pPresetsEnumDef, buf);
  109.                         }
  110.                 }
  111. #endif
  112.  
  113.                 static const SInputPortConfig in_config[] = {
  114.                         InputPortConfig_Void("Trigger",           _HELP("Trigger to start shaking")),
  115.                         InputPortConfig<int>("Restrict",          ER_None,                                   _HELP("Restriction"),                                                                                                                              0,      _UICONFIG("enum_int:None=0,NoVehicle=1,InVehicle=2")),
  116.                         InputPortConfig<int>("View",              VT_FirstPerson,                            _HELP("Which view to use. FirstPerson or Current (might be Trackview)."),                                                                          0,      _UICONFIG("enum_int:FirstPerson=0,Current=1")),
  117.                         InputPortConfig<bool>("GroundOnly",       false,                                     _HELP("Apply shake only when the player is standing on the ground")),
  118.                         InputPortConfig<bool>("Smooth",           false,                                     _HELP("Smooth shakes avoid sudden direction changes.")),
  119.                         InputPortConfig<Vec3>("Angle",            Vec3(0.7f,                                 0.7f,                                                                                                                                              0.7f),  _HELP("Shake Angles")),
  120.                         InputPortConfig<Vec3>("Shift",            Vec3(0.01f,                                0.01f,                                                                                                                                             0.01f), _HELP("Shake shifting")),
  121.                         InputPortConfig<float>("Frequency",       12.0f,                                     _HELP("Frequency. Can be changed dynamically."),                                                                                                   0,      _UICONFIG("v_min=0,v_max=100")),
  122.                         InputPortConfig<float>("Randomness",      1.f,                                       _HELP("Randomness")),
  123.                         InputPortConfig<float>("Distance",        0.0f,                                      _HELP("Distance to effect source. If an entity is asociated to the node, distance from that entity to the current camera will be used instead")),
  124.                         InputPortConfig<float>("RangeMin",        0.0f,                                      _HELP("Maximum strength effect range")),
  125.                         InputPortConfig<float>("RangeMax",        30.0f,                                     _HELP("Effect range")),
  126.                         InputPortConfig<float>("SustainDuration", 0.f,                                       _HELP("duration of the non fading part of the shake. (total duration is fadein + this + fadeout ). -1 = permanent")),
  127.                         InputPortConfig<float>("FadeInDuration",  0.f,                                       _HELP("Fade in time (seconds)")),
  128.                         InputPortConfig<float>("FadeOutDuration", 3.f,                                       _HELP("Fade out time (seconds)")),
  129.                         InputPortConfig_Void("Stop",              _HELP("Stop the shaking (will fade out)")),
  130. #ifdef _RELEASE
  131.                         InputPortConfig<int>("Preset",            0,                                         _HELP("Preset input values. When this is used, all parameter inputs are ignored.")),
  132. #else
  133.                         InputPortConfig<int>("Preset",            0,                                         pPresetsHelp,                                                                                                                                      0,      _UICONFIG(pPresetsEnumDef)),
  134. #endif
  135.                         { 0 }
  136.                 };
  137.                 config.nFlags |= EFLN_TARGET_ENTITY;
  138.                 config.sDescription = _HELP("Camera View Shake node. If an entity is provided, its position will be used for the distance calculations instead of the raw 'distance' input.");
  139.                 config.pInputPorts = in_config;
  140.                 config.pOutputPorts = 0;
  141.                 config.SetCategory(EFLN_APPROVED);
  142.         }
  143.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  144.         {
  145.                 switch (event)
  146.                 {
  147.                 case eFE_Initialize:
  148.                         StopShake(pActInfo);
  149.                         break;
  150.                 case eFE_Activate:
  151.                         if (IsPortActive(pActInfo, EIP_Stop))
  152.                         {
  153.                                 StopShake(pActInfo);
  154.                         }
  155.                         else
  156.                         {
  157.                                 const bool bTriggered = IsPortActive(pActInfo, EIP_Trigger);
  158.                                 const bool bFreqTriggered = IsPortActive(pActInfo, EIP_Frequency);
  159.                                 if (bTriggered || bFreqTriggered)
  160.                                 {
  161.                                         Shake(pActInfo, !bTriggered && bFreqTriggered);
  162.                                 }
  163.                         }
  164.                         break;
  165.                 }
  166.         }
  167.  
  168.         //----------------------------------------------------------------------
  169.         void StopShake(SActivationInfo* pActInfo)
  170.         {
  171.                 IView* pView = GetView(pActInfo);
  172.                 if (pView)
  173.                         pView->StopShake(FLOWGRAPH_SHAKE_ID);
  174.         }
  175.  
  176.         //----------------------------------------------------------------------
  177.         void Shake(SActivationInfo* pActInfo, bool bUpdateOnly)
  178.         {
  179.                 IView* pView = GetView(pActInfo);
  180.                 if (!pView)
  181.                         return;
  182.  
  183.                 int currentFrameId = gEnv->pRenderer->GetFrameID();
  184.  
  185.                 if (!bUpdateOnly && (m_lastShakeFrameID == currentFrameId))
  186.                         return;
  187.  
  188.                 SInputParams inputParams;
  189.                 ReadCurrentInputParams(pActInfo, inputParams);
  190.  
  191.                 IView::SShakeParams params;
  192.  
  193.                 params.bGroundOnly = inputParams.groundOnly;
  194.                 params.isSmooth = inputParams.isSmooth;
  195.                 params.shakeAngle = inputParams.angle;
  196.                 params.shakeShift = inputParams.shift;
  197.                 params.sustainDuration = inputParams.sustainDuration;
  198.                 params.bPermanent = (params.sustainDuration == -1);
  199.                 float freq = inputParams.frequency;
  200.                 if (iszero(freq) == false)
  201.                         freq = 1.0f / freq;
  202.                 params.frequency = freq;
  203.                 params.randomness = inputParams.randomness;
  204.                 params.bFlipVec = true;           // GetPortBool(pActInfo, EIP_Flip);
  205.                 params.bUpdateOnly = bUpdateOnly; // it's an update if and only if Frequency has been changed
  206.                 params.fadeInDuration = inputParams.fadeInDuration;
  207.                 params.fadeOutDuration = inputParams.fadeOutDuration;
  208.                 params.shakeID = FLOWGRAPH_SHAKE_ID;
  209.  
  210.                 float distance = inputParams.distance;
  211.                 IEntity* pEntityNode = pActInfo->pEntity;
  212.                 if (pEntityNode)
  213.                 {
  214.                         distance = pView->GetCurrentParams()->position.GetDistance(pEntityNode->GetWorldPos());
  215.                 }
  216.  
  217.                 const float rangeMin = inputParams.rangeMin;
  218.                 const float rangeMax = inputParams.rangeMax;
  219.                 float amount = min(1.f, max(0.f, (rangeMax - distance) / (rangeMax - rangeMin)));
  220.  
  221.                 params.shakeAngle *= amount;
  222.                 params.shakeShift *= amount;
  223.  
  224.                 pView->SetViewShakeEx(params);
  225.  
  226.                 m_lastShakeFrameID = currentFrameId;
  227.         }
  228.  
  229.         //----------------------------------------------------------------------
  230.         IView* GetView(SActivationInfo* pActInfo)
  231.         {
  232.                 SInputParams inputParams;
  233.                 ReadCurrentInputParams(pActInfo, inputParams);
  234.                 IGameFramework* pGF = gEnv->pGameFramework;
  235.                 IView* pView = 0;
  236.                 IView* pActiveView = pGF->GetIViewSystem()->GetActiveView();
  237.                 eViewType viewType = inputParams.view;
  238.                 if (viewType == VT_FirstPerson) // use player's view
  239.                 {
  240.                         IActor* pActor = pGF->GetClientActor();
  241.                         if (pActor == 0)
  242.                                 return NULL;
  243.  
  244.                         eRestriction restriction = inputParams.restriction;
  245.                         if (restriction != ER_None)
  246.                         {
  247.                                 IVehicle* pVehicle = pActor->GetLinkedVehicle();
  248.                                 if (restriction == ER_InVehicle && pVehicle == 0)
  249.                                         return NULL;
  250.                                 if (restriction == ER_NoVehicle && pVehicle != 0 /* && pVehicle->GetSeatForPassenger(entityId) != 0 */)
  251.                                         return NULL;
  252.                         }
  253.  
  254.                         EntityId entityId = pActor->GetEntityId();
  255.                         pView = pGF->GetIViewSystem()->GetViewByEntityId(entityId);
  256.                 }
  257.                 else // active view
  258.                 {
  259.                         pView = pActiveView;
  260.                 }
  261.                 if (pView != pActiveView)
  262.                         return NULL;
  263.  
  264.                 return pView;
  265.         }
  266.  
  267.         //----------------------------------------------------------------------
  268.         void ReadCurrentInputParams(SActivationInfo* pActInfo, SInputParams& inputParams)
  269.         {
  270.                 int presetIndex = GetPortInt(pActInfo, EIP_Preset);
  271.                 if (presetIndex > 0 && presetIndex <= NUM_PRESETS)
  272.                 {
  273.                         inputParams = m_Presets[presetIndex - 1];
  274.                         inputParams.angle = Ang3(DEG2RAD(m_Presets[presetIndex - 1].angle));
  275.                 }
  276.                 else
  277.                 {
  278.                         inputParams.groundOnly = GetPortBool(pActInfo, EIP_GroundOnly);
  279.                         inputParams.isSmooth = GetPortBool(pActInfo, EIP_Smooth);
  280.                         inputParams.restriction = eRestriction(GetPortInt(pActInfo, EIP_Restriction));
  281.                         inputParams.view = eViewType(GetPortInt(pActInfo, EIP_ViewType));
  282.                         inputParams.angle = Ang3(DEG2RAD(GetPortVec3(pActInfo, EIP_Angle)));
  283.                         inputParams.shift = GetPortVec3(pActInfo, EIP_Shift);
  284.                         inputParams.frequency = GetPortFloat(pActInfo, EIP_Frequency);
  285.                         inputParams.randomness = GetPortFloat(pActInfo, EIP_Randomness);
  286.                         inputParams.distance = GetPortFloat(pActInfo, EIP_Distance);
  287.                         inputParams.rangeMin = GetPortFloat(pActInfo, EIP_RangeMin);
  288.                         inputParams.rangeMax = GetPortFloat(pActInfo, EIP_RangeMax);
  289.                         inputParams.sustainDuration = GetPortFloat(pActInfo, EIP_SustainDuration);
  290.                         inputParams.fadeInDuration = GetPortFloat(pActInfo, EIP_FadeInDuration);
  291.                         inputParams.fadeOutDuration = GetPortFloat(pActInfo, EIP_FadeOutDuration);
  292.                 }
  293.         }
  294.  
  295.         static SInputParams m_Presets[NUM_PRESETS];
  296.         int                 m_lastShakeFrameID;
  297. };
  298.  
  299. CFlowNode_CameraViewShakeEx::SInputParams CFlowNode_CameraViewShakeEx::m_Presets[] =
  300. {
  301.         //                                             Ground Smooth      angle                      shift                                                                                                      fr  rnd                 d   rm  rm   sd   fi     fo
  302.         { "DistantExplosion", ER_None, VT_FirstPerson, false, false, Ang3(0.6f,  0.6f,  0.6f),  Vec3(0.001f,   0.001f,   0.001f),   10, 2,    0, 0, 30, 0, 0.2f, 1.2f },
  303.         { "CloseExplosion",   ER_None, VT_FirstPerson, false, false, Ang3(0.5f,  0.5f,  0.5f),  Vec3(0.003f,   0.003f,   0.003f),   30, 5,    0, 0, 30, 0, 0,    1.1f },
  304.         { "SmallTremor",      ER_None, VT_FirstPerson, false, false, Ang3(0.2f,  0.2f,  0.2f),  Vec3(0.0001f,  0.0001f,  0.0001f),  18, 1.3f, 0, 0, 30, 2, 1.2f, 3.f  },
  305.         { "SmallTremor2",     ER_None, VT_FirstPerson, false, false, Ang3(0.25f, 0.25f, 0.25f), Vec3(0.00045f, 0.00045f, 0.00045f), 13, 2,    0, 0, 30, 2, 1.2f, 3.f  },
  306. };
  307.  
  308. //////////////////////////////////////////////////////////////////////////
  309. class CFlowNode_CameraView : public CFlowBaseNode<eNCT_Instanced>
  310. {
  311. private:
  312.         IView*       m_pView;
  313.         IView*       m_pLocalPlayerView;
  314.         IViewSystem* m_pViewSystem;
  315.  
  316. public:
  317.         CFlowNode_CameraView(SActivationInfo* pActInfo) :
  318.                 m_pView(NULL),
  319.                 m_pLocalPlayerView(NULL),
  320.                 m_pViewSystem(NULL)
  321.         {
  322.         }
  323.  
  324.         ~CFlowNode_CameraView()
  325.         {
  326.                 if (m_pViewSystem && m_pView)
  327.                 {
  328.                         m_pViewSystem->RemoveView(m_pView);
  329.                 }
  330.         }
  331.  
  332.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  333.         {
  334.                 return new CFlowNode_CameraView(pActInfo);
  335.         }
  336.  
  337.         virtual void GetMemoryUsage(ICrySizer* s) const
  338.         {
  339.                 s->Add(*this);
  340.         }
  341.  
  342.         enum EInputPorts
  343.         {
  344.                 EIP_Enable = 0,
  345.                 EIP_Disable,
  346.                 EIP_FOV,
  347.                 EIP_Blend,
  348.                 EIP_BlendFOVSpeed,
  349.                 EIP_BlendFOVOffset,
  350.                 EIP_BlendPosSpeed,
  351.                 EIP_BlendPosOffset,
  352.                 EIP_BlendRotSpeed,
  353.                 EIP_BlendRotOffset
  354.         };
  355.  
  356.         virtual void GetConfiguration(SFlowNodeConfig& config)
  357.         {
  358.                 static const SInputPortConfig in_config[] = {
  359.                         InputPortConfig<bool>("Enable",          "Enable custom view"),
  360.                         InputPortConfig<bool>("Disable",         "Disable custom view"),
  361.                         InputPortConfig<float>("FOV",            60.0f,                 "Field of View used by the custom view"),
  362.                         InputPortConfig<bool>("Blend",           false,                 "Enables FOV, Position and Rotation blending"),
  363.                         InputPortConfig<float>("BlendFOVSpeed",  5.0f,                  "How fast to blend in the FOV offset"),
  364.                         InputPortConfig<float>("BlendFOVOffset", 0.0f,                  "FOV offset"),
  365.                         InputPortConfig<float>("BlendPosSpeed",  5.0f,                  "How fast to blend in the position offset"),
  366.                         InputPortConfig<Vec3>("BlendPosOffset",  Vec3(ZERO),            "Position offset"),
  367.                         InputPortConfig<float>("BlendRotSpeed",  10.0f,                 "How fast to blend in the rotation offset"),
  368.                         InputPortConfig<Vec3>("BlendRotOffset",  Vec3(ZERO),            "Rotation offset"),
  369.                         { 0 }
  370.                 };
  371.  
  372.                 config.nFlags |= EFLN_TARGET_ENTITY;
  373.                 config.pInputPorts = in_config;
  374.                 config.sDescription = _HELP("Creates a custom view linked to an entity");
  375.                 config.SetCategory(EFLN_APPROVED);
  376.         }
  377.  
  378.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  379.         {
  380.                 switch (event)
  381.                 {
  382.                 case eFE_Initialize:
  383.                         {
  384.                                 CreateView();
  385.                                 return;
  386.                         }
  387.                         break;
  388.                 case eFE_Activate:
  389.                         {
  390.                                 if (IsPortActive(pActInfo, EIP_Enable))
  391.                                 {
  392.                                         if (m_pView == NULL)
  393.                                                 CreateView();
  394.  
  395.                                         if (m_pView == NULL)
  396.                                                 return;
  397.  
  398.                                         if (pActInfo->pEntity == NULL)
  399.                                                 return;
  400.  
  401.                                         SViewParams params;
  402.  
  403.                                         params.justActivated = true;
  404.                                         params.fov = DEG2RAD(GetPortFloat(pActInfo, EIP_FOV));
  405.                                         params.blend = GetPortBool(pActInfo, EIP_Blend);
  406.                                         params.blendFOVOffset = DEG2RAD(GetPortFloat(pActInfo, EIP_BlendFOVOffset));
  407.                                         params.blendFOVSpeed = GetPortFloat(pActInfo, EIP_BlendFOVSpeed);
  408.                                         params.blendPosOffset = GetPortVec3(pActInfo, EIP_BlendPosOffset);
  409.                                         params.blendPosSpeed = GetPortFloat(pActInfo, EIP_BlendPosSpeed);
  410.                                         params.blendRotSpeed = GetPortFloat(pActInfo, EIP_BlendRotSpeed);
  411.                                         params.blendRotOffset = Quat::CreateRotationXYZ(static_cast<Ang3>(GetPortVec3(pActInfo, EIP_BlendRotOffset)));
  412.  
  413.                                         m_pView->SetCurrentParams(params);
  414.                                         m_pView->LinkTo(pActInfo->pEntity);
  415.  
  416.                                         m_pViewSystem->SetActiveView(m_pView);
  417.                                 }
  418.                                 else if (IsPortActive(pActInfo, EIP_Disable))
  419.                                 {
  420.                                         if (m_pLocalPlayerView)
  421.                                                 m_pViewSystem->SetActiveView(m_pLocalPlayerView);
  422.                                 }
  423.                                 else if (IsPortActive(pActInfo, EIP_FOV))
  424.                                 {
  425.                                         SViewParams params;
  426.                                         params.fov = DEG2RAD(GetPortFloat(pActInfo, EIP_FOV));
  427.                                         m_pView->SetCurrentParams(params);
  428.                                 }
  429.                         }
  430.                         break;
  431.                 }
  432.         }
  433.  
  434.         void CreateView()
  435.         {
  436.                 IGameFramework* pGF = gEnv->pGameFramework;
  437.                 if (pGF == NULL)
  438.                         return;
  439.  
  440.                 m_pViewSystem = pGF->GetIViewSystem();
  441.  
  442.                 if (m_pViewSystem == NULL)
  443.                         return;
  444.                 //if the game has a clientactor, cache the view
  445.                 if (pGF->GetClientActor())
  446.                 {
  447.                         m_pLocalPlayerView = m_pViewSystem->GetViewByEntityId(pGF->GetClientActor()->GetEntityId());
  448.                 }
  449.  
  450.                 if (m_pLocalPlayerView && (m_pViewSystem->GetActiveView() != m_pLocalPlayerView))
  451.                         m_pViewSystem->SetActiveView(m_pLocalPlayerView);
  452.  
  453.                 if (m_pView == NULL)
  454.                         m_pView = m_pViewSystem->CreateView();
  455.         }
  456. };
  457.  
  458. //////////////////////////////////////////////////////////////////////////
  459. class CFlowNode_CameraTransform : public CFlowBaseNode<eNCT_Singleton>
  460. {
  461. public:
  462.         CFlowNode_CameraTransform(SActivationInfo* pActInfo){}
  463.  
  464.         ~CFlowNode_CameraTransform() {}
  465.  
  466.         virtual void GetMemoryUsage(ICrySizer* s) const
  467.         {
  468.                 s->Add(*this);
  469.         }
  470.  
  471.         enum EInputPorts
  472.         {
  473.                 EIP_Get = 0,
  474.         };
  475.  
  476.         enum EOutputPorts
  477.         {
  478.                 EOP_Pos = 0,
  479.                 EOP_Dir,
  480.         };
  481.  
  482.         virtual void GetConfiguration(SFlowNodeConfig& config)
  483.         {
  484.                 static const SInputPortConfig in_config[] = {
  485.                         InputPortConfig_Void("Get", "Returns the Pos/Dir of the camera"),
  486.                         { 0 }
  487.                 };
  488.                 static const SOutputPortConfig out_config[] = {
  489.                         OutputPortConfig<Vec3>("Pos", "Position of the camera"),
  490.                         OutputPortConfig<Vec3>("Dir", "ViewDir of the camera"),
  491.                         { 0 }
  492.                 };
  493.  
  494.                 config.pInputPorts = in_config;
  495.                 config.pOutputPorts = out_config;
  496.                 config.sDescription = _HELP("Returns the transform for the playercamera");
  497.                 config.SetCategory(EFLN_APPROVED);
  498.         }
  499.  
  500.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  501.         {
  502.                 switch (event)
  503.                 {
  504.                 case eFE_Activate:
  505.                         {
  506.                                 if (IsPortActive(pActInfo, EIP_Get))
  507.                                 {
  508.                                         CCamera& cam = GetISystem()->GetViewCamera();
  509.                                         ActivateOutput(pActInfo, EOP_Pos, cam.GetPosition());
  510.                                         ActivateOutput(pActInfo, EOP_Dir, cam.GetViewdir());
  511.                                 }
  512.  
  513.                         }
  514.                         break;
  515.                 }
  516.         }
  517. };
  518.  
  519. REGISTER_FLOW_NODE("Camera:ViewShakeEx", CFlowNode_CameraViewShakeEx);
  520. REGISTER_FLOW_NODE("Camera:View", CFlowNode_CameraView);
  521. REGISTER_FLOW_NODE("Camera:GetTransform", CFlowNode_CameraTransform);
  522.  
downloadFlowCameraNodes.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