BVB Source Codes

CRYENGINE Show FlowEngineEffectsNodes.cpp Source code

Return Download CRYENGINE: download FlowEngineEffectsNodes.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. // Note: why is there a Enable + Disable ? Quite redundant
  7.  
  8. ////////////////////////////////////////////////////////////////////////////////////////////////////
  9. // Get custom value helper functions
  10. ////////////////////////////////////////////////////////////////////////////////////////////////////
  11.  
  12. typedef CFlowFrameworkBaseNode<eNCT_Singleton> TBaseNodeClass;
  13.  
  14. static float GetCustomValue(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo, int portIndex, bool& isOk)
  15. {
  16.         float customValue = 0.0f;
  17.         if (pFlowBaseNode && pActInfo && isOk)
  18.         {
  19.                 if (bIsEnabled)
  20.                 {
  21.                         isOk = GetPortAny(pActInfo, portIndex).GetValueWithConversion(customValue);
  22.                 }
  23.                 else
  24.                 {
  25.                         isOk = config.pInputPorts[portIndex].defaultData.GetValueWithConversion(customValue);
  26.                 }
  27.         }
  28.         return customValue;
  29. }
  30.  
  31. static void GetCustomValueVec3(Vec3& customValue, const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo, int portIndex, bool& isOk)
  32. {
  33.         if (pFlowBaseNode && pActInfo && isOk)
  34.         {
  35.                 if (bIsEnabled)
  36.                 {
  37.                         isOk = GetPortAny(pActInfo, portIndex).GetValueWithConversion(customValue);
  38.                 }
  39.                 else
  40.                 {
  41.                         isOk = config.pInputPorts[portIndex].defaultData.GetValueWithConversion(customValue);
  42.                 }
  43.         }
  44. }
  45.  
  46. ////////////////////////////////////////////////////////////////////////////////////////////////////
  47. // Color correction
  48. ////////////////////////////////////////////////////////////////////////////////////////////////////
  49.  
  50. struct SColorCorrection
  51. {
  52.         static void GetConfiguration(SFlowNodeConfig& config)
  53.         {
  54.                 static const SInputPortConfig inputs[] =
  55.                 {
  56.                         InputPortConfig<bool>("Enabled",                 false, "Enables node",  "Enabled"),
  57.                         InputPortConfig<bool>("Disabled",                true,  "Disables node", "Disabled"),
  58.                         InputPortConfig<float>("Global_User_ColorC",     0.0f,  0,               "Cyan"),
  59.                         InputPortConfig<float>("Global_User_ColorM",     0.0f,  0,               "Magenta"),
  60.                         InputPortConfig<float>("Global_User_ColorY",     0.0f,  0,               "Yellow"),
  61.                         InputPortConfig<float>("Global_User_ColorK",     0.0f,  0,               "Luminance"),
  62.                         InputPortConfig<float>("Global_User_Brightness", 1.0f,  0,               "Brightness"),
  63.                         InputPortConfig<float>("Global_User_Contrast",   1.0f,  0,               "Contrast"),
  64.                         InputPortConfig<float>("Global_User_Saturation", 1.0f,  0,               "Saturation"),
  65.                         InputPortConfig<float>("Global_User_ColorHue",   0.0f,  "Change Hue",    "Hue"),
  66.                         { 0 }
  67.                 };
  68.  
  69.                 static const SOutputPortConfig outputs[] =
  70.                 {
  71.                         { 0 }
  72.                 };
  73.  
  74.                 config.nFlags |= EFLN_TARGET_ENTITY;
  75.                 config.pInputPorts = inputs;
  76.                 config.pOutputPorts = outputs;
  77.                 config.sDescription = _HELP("Sets color correction parameters");
  78.         }
  79.  
  80.         static void Disable()
  81.         {
  82.                 SFlowNodeConfig config;
  83.                 GetConfiguration(config);
  84.                 I3DEngine* pEngine = gEnv->p3DEngine;
  85.  
  86.                 for (int i = 2; config.pInputPorts[i].name; ++i)
  87.                 {
  88.                         if (config.pInputPorts[i].defaultData.GetType() == eFDT_Float)
  89.                         {
  90.                                 float fVal;
  91.                                 bool ok = config.pInputPorts[i].defaultData.GetValueWithConversion(fVal);
  92.                                 if (ok)
  93.                                         pEngine->SetPostEffectParam(config.pInputPorts[i].name, fVal);
  94.                         }
  95.                 }
  96.         }
  97.  
  98.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  99.  
  100.         static void Serialize(IFlowNode::SActivationInfo* actInfo, TSerialize ser)                                                                     {}
  101. };
  102.  
  103. ////////////////////////////////////////////////////////////////////////////////////////////////////
  104. // Filters
  105. ////////////////////////////////////////////////////////////////////////////////////////////////////
  106.  
  107. struct SFilterBlur
  108. {
  109.         static void GetConfiguration(SFlowNodeConfig& config)
  110.         {
  111.                 static const SInputPortConfig inputs[] =
  112.                 {
  113.                         InputPortConfig<bool>("Enabled",                false, "Enables node",                 "Enabled"),
  114.                         InputPortConfig<bool>("Disabled",               true,  "Disables node",                "Disabled"),
  115.                         InputPortConfig<int>("FilterBlurring_Type",     0,     "Set blur type, 0 is Gaussian", "Type"),
  116.                         InputPortConfig<float>("FilterBlurring_Amount", 0.0f,  "Amount of blurring",           "Amount"),
  117.                         { 0 }
  118.                 };
  119.  
  120.                 static const SOutputPortConfig outputs[] =
  121.                 {
  122.                         { 0 }
  123.                 };
  124.  
  125.                 config.nFlags |= EFLN_TARGET_ENTITY;
  126.                 config.pInputPorts = inputs;
  127.                 config.pOutputPorts = outputs;
  128.                 config.sDescription = _HELP("Sets blur filter");
  129.         }
  130.  
  131.         static void Disable()
  132.         {
  133.                 gEnv->p3DEngine->SetPostEffectParam("FilterBlurring_Amount", 0);
  134.         }
  135.  
  136.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  137.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  138. };
  139.  
  140. struct SFilterRadialBlur
  141. {
  142.         static void GetConfiguration(SFlowNodeConfig& config)
  143.         {
  144.                 static const SInputPortConfig inputs[] =
  145.                 {
  146.                         InputPortConfig<bool>("Enabled",                          false, "Enables node",               "Enabled"),
  147.                         InputPortConfig<bool>("Disabled",                         true,  "Disables node",              "Disabled"),
  148.                         InputPortConfig<float>("FilterRadialBlurring_Amount",     0.0f,  "Amount of blurring",         "Amount"),
  149.                         InputPortConfig<float>("FilterRadialBlurring_ScreenPosX", 0.5f,  "Horizontal screen position", "ScreenPosX"),
  150.                         InputPortConfig<float>("FilterRadialBlurring_ScreenPosY", 0.5f,  "Vertical screen position",   "ScreenPosY"),
  151.                         InputPortConfig<float>("FilterRadialBlurring_Radius",     1.0f,  "Blurring radius",            "BlurringRadius"),
  152.                         { 0 }
  153.                 };
  154.  
  155.                 static const SOutputPortConfig outputs[] =
  156.                 {
  157.                         { 0 }
  158.                 };
  159.  
  160.                 config.nFlags |= EFLN_TARGET_ENTITY;
  161.                 config.pInputPorts = inputs;
  162.                 config.pOutputPorts = outputs;
  163.                 config.sDescription = _HELP("Sets radial blur filter");
  164.         }
  165.  
  166.         static void Disable()
  167.         {
  168.                 gEnv->p3DEngine->SetPostEffectParam("FilterRadialBlurring_Amount", 0);
  169.         }
  170.  
  171.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  172.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  173. };
  174.  
  175. struct SFilterSharpen
  176. {
  177.         static void GetConfiguration(SFlowNodeConfig& config)
  178.         {
  179.                 static const SInputPortConfig inputs[] =
  180.                 {
  181.                         InputPortConfig<bool>("Enabled",                  false, "Enables node",                              "Enabled"),
  182.                         InputPortConfig<bool>("Disabled",                 true,  "Disables node",                             "Disabled"),
  183.                         InputPortConfig<int>("FilterSharpening_Type",     0,     "Sets sharpening filter, 0 is Unsharp Mask", "Type"),
  184.                         InputPortConfig<float>("FilterSharpening_Amount", 1.0f,  "Amount of sharpening",                      "Amount"),
  185.                         { 0 }
  186.                 };
  187.  
  188.                 static const SOutputPortConfig outputs[] =
  189.                 {
  190.                         { 0 }
  191.                 };
  192.  
  193.                 config.nFlags |= EFLN_TARGET_ENTITY;
  194.                 config.pInputPorts = inputs;
  195.                 config.pOutputPorts = outputs;
  196.                 config.sDescription = _HELP("Sets sharpen filter");
  197.         }
  198.  
  199.         static void Disable()
  200.         {
  201.                 gEnv->p3DEngine->SetPostEffectParam("FilterSharpening_Amount", 1.0f);
  202.         }
  203.  
  204.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  205.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  206. };
  207.  
  208. struct SFilterChromaShift
  209. {
  210.         static void GetConfiguration(SFlowNodeConfig& config)
  211.         {
  212.                 static const SInputPortConfig inputs[] =
  213.                 {
  214.                         InputPortConfig<bool>("Enabled",                        false, "Enables node",           "Enabled"),
  215.                         InputPortConfig<bool>("Disabled",                       true,  "Disables node",          "Disabled"),
  216.                         InputPortConfig<float>("FilterChromaShift_User_Amount", 0.0f,  "Amount of chroma shift", "Amount"),
  217.                         { 0 }
  218.                 };
  219.  
  220.                 static const SOutputPortConfig outputs[] =
  221.                 {
  222.                         { 0 }
  223.                 };
  224.  
  225.                 config.nFlags |= EFLN_TARGET_ENTITY;
  226.                 config.pInputPorts = inputs;
  227.                 config.pOutputPorts = outputs;
  228.                 config.sDescription = _HELP("Sets chroma shift filter");
  229.         }
  230.  
  231.         static void Disable()
  232.         {
  233.                 gEnv->p3DEngine->SetPostEffectParam("FilterChromaShift_User_Amount", 0);
  234.         }
  235.  
  236.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  237.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  238. };
  239.  
  240. struct SFilterGrain
  241. {
  242.         static void GetConfiguration(SFlowNodeConfig& config)
  243.         {
  244.                 static const SInputPortConfig inputs[] =
  245.                 {
  246.                         InputPortConfig<bool>("Enabled",             false, "Enables node",    "Enabled"),
  247.                         InputPortConfig<bool>("Disabled",            true,  "Disables node",   "Disabled"),
  248.                         InputPortConfig<float>("FilterGrain_Amount", 0.0f,  "Amount of grain", "Amount"),
  249.                         { 0 }
  250.                 };
  251.  
  252.                 static const SOutputPortConfig outputs[] =
  253.                 {
  254.                         { 0 }
  255.                 };
  256.  
  257.                 config.nFlags |= EFLN_TARGET_ENTITY;
  258.                 config.pInputPorts = inputs;
  259.                 config.pOutputPorts = outputs;
  260.                 config.sDescription = _HELP("Sets grain filter");
  261.         }
  262.  
  263.         static void Disable()
  264.         {
  265.                 gEnv->p3DEngine->SetPostEffectParam("FilterGrain_Amount", 0);
  266.         }
  267.  
  268.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  269.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  270. };
  271.  
  272. struct SFilterVisualArtifacts
  273. {
  274.         static void GetConfiguration(SFlowNodeConfig& config)
  275.         {
  276.                 static const SInputPortConfig inputs[] =
  277.                 {
  278.                         InputPortConfig<bool>("Enabled",                            false,                  "Enables node",                  "Enabled"),
  279.                         InputPortConfig<bool>("Disabled",                           true,                   "Disables node",                 "Disabled"),
  280.  
  281.                         InputPortConfig<float>("VisualArtifacts_Vsync",             0.0f,                   "Amount of vsync visible",       "VSync"),
  282.                         InputPortConfig<float>("VisualArtifacts_VsyncFreq",         1.0f,                   "Vsync frequency",               "VSync frequency"),
  283.  
  284.                         InputPortConfig<float>("VisualArtifacts_Interlacing",       0.0f,                   "Amount of interlacing visible", "Interlacing"),
  285.                         InputPortConfig<float>("VisualArtifacts_InterlacingTile",   1.0f,                   "Interlacing tilling",           "Interlacing tiling"),
  286.                         InputPortConfig<float>("VisualArtifacts_InterlacingRot",    0.0f,                   "Interlacing rotation",          "Interlacing rotation"),
  287.  
  288.                         InputPortConfig<float>("VisualArtifacts_SyncWavePhase",     0.0f,                   "Sync wave phase",               "Sync wave phase"),
  289.                         InputPortConfig<float>("VisualArtifacts_SyncWaveFreq",      0.0f,                   "Sync wave frequency",           "Sync wave frequency"),
  290.                         InputPortConfig<float>("VisualArtifacts_SyncWaveAmplitude", 0.0f,                   "Sync wave amplitude",           "Sync wave amplitude"),
  291.  
  292.                         InputPortConfig<float>("FilterArtifacts_ChromaShift",       0.0f,                   "Chroma shift",                  "Chroma shift"),
  293.  
  294.                         InputPortConfig<float>("FilterArtifacts_Grain",             0.0f,                   "Image grain amount",            "Grain"),
  295.  
  296.                         InputPortConfig<Vec3>("clr_VisualArtifacts_ColorTint",      Vec3(1.0f,              1.0f,                            1.0f),                  0,"Color tinting"),
  297.  
  298.                         InputPortConfig<string>("tex_VisualArtifacts_Mask",         _HELP("Texture Name")),
  299.  
  300.                         { 0 }
  301.                 };
  302.  
  303.                 static const SOutputPortConfig outputs[] =
  304.                 {
  305.                         { 0 }
  306.                 };
  307.  
  308.                 config.nFlags |= EFLN_TARGET_ENTITY;
  309.                 config.pInputPorts = inputs;
  310.                 config.pOutputPorts = outputs;
  311.                 config.sDescription = _HELP("Sets image visual artefacts parameters");
  312.         }
  313.  
  314.         static void Disable()
  315.         {
  316.                 gEnv->p3DEngine->SetPostEffectParam("tex_VisualArtifacts_Mask", 0);
  317.                 gEnv->p3DEngine->SetPostEffectParamVec4("clr_VisualArtifacts_ColorTint", Vec4(1.0f, 1.0f, 1.0f, 1.0f));
  318.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_Vsync", 0.0f);
  319.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_VsyncFreq", 1.0f);
  320.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_Interlacing", 0.0f);
  321.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_InterlacingTile", 1.0f);
  322.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_InterlacingRot", 0.0f);
  323.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_Pixelation", 0.0f);
  324.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_Noise", 0.0f);
  325.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_SyncWavePhase", 0.0f);
  326.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_SyncWaveFreq", 0.0f);
  327.                 gEnv->p3DEngine->SetPostEffectParam("VisualArtifacts_SyncWaveAmplitude", 0.0f);
  328.                 gEnv->p3DEngine->SetPostEffectParam("FilterArtifacts_ChromaShift", 0.0f);
  329.                 gEnv->p3DEngine->SetPostEffectParam("FilterArtifacts_Grain", 0.0f);
  330.                 gEnv->p3DEngine->SetPostEffectParam("FilterArtifacts_GrainTile", 1.0f);
  331.         }
  332.  
  333.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  334.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  335. };
  336.  
  337. ////////////////////////////////////////////////////////////////////////////////////////////////////
  338. // Effects
  339. ////////////////////////////////////////////////////////////////////////////////////////////////////
  340.  
  341. struct SEffectFrost
  342. {
  343.         static void GetConfiguration(SFlowNodeConfig& config)
  344.         {
  345.                 static const SInputPortConfig inputs[] =
  346.                 {
  347.                         InputPortConfig<bool>("Enabled",                   false, "Enables node",                        "Enabled"),
  348.                         InputPortConfig<bool>("Disabled",                  true,  "Disables node",                       "Disabled"),
  349.                         InputPortConfig<float>("ScreenFrost_Amount",       0.0f,  "Amount of frost",                     "Amount"),
  350.                         InputPortConfig<float>("ScreenFrost_CenterAmount", 1.0f,  "Amount of frost at center of screen", "CenterAmount"),
  351.                         { 0 }
  352.                 };
  353.  
  354.                 static const SOutputPortConfig outputs[] =
  355.                 {
  356.                         { 0 }
  357.                 };
  358.  
  359.                 config.nFlags |= EFLN_TARGET_ENTITY;
  360.                 config.pInputPorts = inputs;
  361.                 config.pOutputPorts = outputs;
  362.                 config.sDescription = _HELP("Freezing effect");
  363.         }
  364.  
  365.         static void Disable()
  366.         {
  367.                 gEnv->p3DEngine->SetPostEffectParam("ScreenFrost_Amount", 0);
  368.         }
  369.  
  370.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  371.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  372. };
  373.  
  374. struct SEffectWaterDroplets
  375. {
  376.         static void GetConfiguration(SFlowNodeConfig& config)
  377.         {
  378.                 static const SInputPortConfig inputs[] =
  379.                 {
  380.                         InputPortConfig<bool>("Enabled",               false, "Enables node",    "Enabled"),
  381.                         InputPortConfig<bool>("Disabled",              true,  "Disables node",   "Disabled"),
  382.                         InputPortConfig<float>("WaterDroplets_Amount", 0.0f,  "Amount of water", "Amount"),
  383.                         { 0 }
  384.                 };
  385.  
  386.                 static const SOutputPortConfig outputs[] =
  387.                 {
  388.                         { 0 }
  389.                 };
  390.  
  391.                 config.nFlags |= EFLN_TARGET_ENTITY;
  392.                 config.pInputPorts = inputs;
  393.                 config.pOutputPorts = outputs;
  394.                 config.sDescription = _HELP("Water droplets effect - Use when camera goes out of water or similar extreme condition");
  395.         }
  396.  
  397.         static void Disable()
  398.         {
  399.                 gEnv->p3DEngine->SetPostEffectParam("WaterDroplets_Amount", 0);
  400.         }
  401.  
  402.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  403.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  404. };
  405.  
  406. struct SEffectWaterFlow
  407. {
  408.         static void GetConfiguration(SFlowNodeConfig& config)
  409.         {
  410.                 static const SInputPortConfig inputs[] =
  411.                 {
  412.                         InputPortConfig<bool>("Enabled",           false, "Enables node",    "Enabled"),
  413.                         InputPortConfig<bool>("Disabled",          true,  "Disables node",   "Disabled"),
  414.                         InputPortConfig<float>("WaterFlow_Amount", 0.0f,  "Amount of water", "Amount"),
  415.                         { 0 }
  416.                 };
  417.  
  418.                 static const SOutputPortConfig outputs[] =
  419.                 {
  420.                         { 0 }
  421.                 };
  422.  
  423.                 config.nFlags |= EFLN_TARGET_ENTITY;
  424.                 config.pInputPorts = inputs;
  425.                 config.pOutputPorts = outputs;
  426.                 config.sDescription = _HELP("Water flow effect - Use when camera receiving splashes of water or similar");
  427.         }
  428.  
  429.         static void Disable()
  430.         {
  431.                 gEnv->p3DEngine->SetPostEffectParam("WaterFlow_Amount", 0);
  432.         }
  433.  
  434.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  435.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  436. };
  437.  
  438. struct SEffectBloodSplats
  439. {
  440.         static void GetConfiguration(SFlowNodeConfig& config)
  441.         {
  442.                 static const SInputPortConfig inputs[] =
  443.                 {
  444.                         InputPortConfig<bool>("Enabled",             false, "Enables node",               "Enabled"),
  445.                         InputPortConfig<bool>("Disabled",            true,  "Disables node",              "Disabled"),
  446.                         InputPortConfig<int>("BloodSplats_Type",     0,     "Blood type: human or alien", "Type"),
  447.                         InputPortConfig<float>("BloodSplats_Amount", 0.0f,  "Amount of visible blood",    "Amount"),
  448.                         InputPortConfig<bool>("BloodSplats_Spawn",   false, "Spawn more blood particles", "Spawn"),
  449.                         { 0 }
  450.                 };
  451.  
  452.                 static const SOutputPortConfig outputs[] =
  453.                 {
  454.                         { 0 }
  455.                 };
  456.  
  457.                 config.nFlags |= EFLN_TARGET_ENTITY;
  458.                 config.pInputPorts = inputs;
  459.                 config.pOutputPorts = outputs;
  460.                 config.sDescription = _HELP("Blood splats effect");
  461.         }
  462.  
  463.         static void Disable()
  464.         {
  465.                 gEnv->p3DEngine->SetPostEffectParam("BloodSplats_Amount", 0);
  466.         }
  467.  
  468.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  469.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  470. };
  471.  
  472. struct SEffectDof
  473. {
  474.         static void GetConfiguration(SFlowNodeConfig& config)
  475.         {
  476.                 static const SInputPortConfig inputs[] =
  477.                 {
  478.                         InputPortConfig<bool>("Enabled",                 false, "Enables node",                  "Enabled"),
  479.                         InputPortConfig<bool>("Disabled",                true,  "Disables node",                 "Disabled"),
  480.                         InputPortConfig<bool>("Dof_User_Active",         false, "Enables dof effect",            "EnableDof"),
  481.                         InputPortConfig<float>("Dof_User_FocusDistance", 3.5f,  "Set focus distance",            "FocusDistance"),
  482.                         InputPortConfig<float>("Dof_User_FocusRange",    5.0f,  "Set focus range",               "FocusRange"),
  483.                         InputPortConfig<float>("Dof_User_BlurAmount",    1.0f,  "Set blurring amount",           "BlurAmount"),
  484.                         InputPortConfig<float>("Dof_MaxCoC",             12.0f, "Set circle of confusion scale", "ScaleCoC"),
  485.                         InputPortConfig<float>("Dof_CenterWeight",       1.0f,  "Set central samples weight",    "CenterWeight"),
  486.                         { 0 }
  487.                 };
  488.  
  489.                 static const SOutputPortConfig outputs[] =
  490.                 {
  491.                         { 0 }
  492.                 };
  493.  
  494.                 config.nFlags |= EFLN_TARGET_ENTITY;
  495.                 config.pInputPorts = inputs;
  496.                 config.pOutputPorts = outputs;
  497.                 config.sDescription = _HELP("Depth of field effect");
  498.         }
  499.  
  500.         static void Disable()
  501.         {
  502.                 gEnv->p3DEngine->SetPostEffectParam("Dof_User_Active", 0);
  503.         }
  504.  
  505.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  506.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  507. };
  508.  
  509. struct SEffectDirectionalBlur
  510. {
  511.         static void GetConfiguration(SFlowNodeConfig& config)
  512.         {
  513.                 static const SInputPortConfig inputs[] =
  514.                 {
  515.                         InputPortConfig<bool>("Enabled",                    false,     "Enables node",  "Enabled"),
  516.                         InputPortConfig<bool>("Disabled",                   true,      "Disables node", "Disabled"),
  517.                         InputPortConfig<Vec3>("Global_DirectionalBlur_Vec", Vec3(0.0f, 0.0f,            0.0f),      "Sets directional blur direction","Direction"),
  518.                         { 0 }
  519.                 };
  520.  
  521.                 static const SOutputPortConfig outputs[] =
  522.                 {
  523.                         { 0 }
  524.                 };
  525.  
  526.                 config.nFlags |= EFLN_TARGET_ENTITY;
  527.                 config.pInputPorts = inputs;
  528.                 config.pOutputPorts = outputs;
  529.                 config.sDescription = _HELP("Directional Blur effect");
  530.         }
  531.  
  532.         static void Disable()
  533.         {
  534.                 Vec4 vec(0, 0, 0, 1);
  535.                 gEnv->p3DEngine->SetPostEffectParamVec4("Global_DirectionalBlur_Vec", vec);
  536.         }
  537.  
  538.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  539.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  540. };
  541.  
  542. struct SEffectAlienInterference
  543. {
  544.         static void GetConfiguration(SFlowNodeConfig& config)
  545.         {
  546.                 static const SInputPortConfig inputs[] =
  547.                 {
  548.                         InputPortConfig<bool>("Enabled",                     false,      "Enables node",                   "Enabled"),
  549.                         InputPortConfig<bool>("Disabled",                    false,      "Disables node",                  "Disabled"),
  550.                         InputPortConfig<float>("AlienInterference_Amount",   0.0f,       "Sets alien interference amount", "Amount"),
  551.                         InputPortConfig<Vec3>("clr_AlienInterference_Color", Vec3(0.85f, 0.95f,                            1.25f) * 0.5f,"Sets volumetric scattering amount","Color"),
  552.  
  553.                         { 0 }
  554.                 };
  555.  
  556.                 static const SOutputPortConfig outputs[] =
  557.                 {
  558.                         { 0 }
  559.                 };
  560.  
  561.                 config.nFlags |= EFLN_TARGET_ENTITY;
  562.                 config.pInputPorts = inputs;
  563.                 config.pOutputPorts = outputs;
  564.                 config.sDescription = _HELP("Alien interference effect");
  565.         }
  566.  
  567.         static void Disable()
  568.         {
  569.                 gEnv->p3DEngine->SetPostEffectParam("AlienInterference_Amount", 0);
  570.                 gEnv->p3DEngine->SetPostEffectParamVec4("clr_AlienInterference_TintColor", Vec4(Vec3(0.85f, 0.95f, 1.25f) * 0.5f, 1.0f));
  571.         }
  572.  
  573.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  574.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  575. };
  576.  
  577. struct SEffectGhostVision
  578. {
  579.         static void GetConfiguration(SFlowNodeConfig& config)
  580.         {
  581.                 static const SInputPortConfig inputs[] =
  582.                 {
  583.                         InputPortConfig<bool>("GhostVision_Bool1",     false,      "User defined bool",  "UserBool1"),
  584.                         InputPortConfig<bool>("GhostVision_Bool2",     false,      "User defined bool",  "UserBool2"),
  585.                         InputPortConfig<bool>("GhostVision_Bool3",     false,      "User defined bool",  "UserBool3"),
  586.                         InputPortConfig<float>("GhostVision_Amount1",  0.0f,       "User defined value", "FloatValue1"),
  587.                         InputPortConfig<float>("GhostVision_Amount2",  0.0f,       "User defined value", "FloatValue2"),
  588.                         InputPortConfig<float>("GhostVision_Amount3",  0.0f,       "User defined value", "FloatValue3"),
  589.                         InputPortConfig<Vec3>("clr_GhostVision_Color", Vec3(0.85f, 0.95f,                1.25f) * 0.5f, "Sets volumetric scattering amount","Color"),
  590.  
  591.                         { 0 }
  592.                 };
  593.  
  594.                 static const SOutputPortConfig outputs[] =
  595.                 {
  596.                         { 0 }
  597.                 };
  598.  
  599.                 config.nFlags |= EFLN_TARGET_ENTITY;
  600.                 config.pInputPorts = inputs;
  601.                 config.pOutputPorts = outputs;
  602.                 config.sDescription = _HELP("Ghost Vision Effect");
  603.         }
  604.  
  605.         static void Disable()
  606.         {
  607.                 gEnv->p3DEngine->SetPostEffectParam("GhostVision_Bool1", 0);
  608.                 gEnv->p3DEngine->SetPostEffectParam("GhostVision_Bool2", 0);
  609.                 gEnv->p3DEngine->SetPostEffectParam("GhostVision_Bool3", 0);
  610.                 gEnv->p3DEngine->SetPostEffectParam("User_FloatValue_1", 0);
  611.                 gEnv->p3DEngine->SetPostEffectParam("User_FloatValue_2", 0);
  612.                 gEnv->p3DEngine->SetPostEffectParam("User_FloatValue_3", 0);
  613.                 gEnv->p3DEngine->SetPostEffectParamVec4("clr_GhostVision_TintColor", Vec4(Vec3(0.85f, 0.95f, 1.25f) * 0.5f, 1.0f));
  614.         }
  615.  
  616.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  617.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  618. };
  619.  
  620. struct SEffectRainDrops
  621. {
  622.         static void GetConfiguration(SFlowNodeConfig& config)
  623.         {
  624.                 static const SInputPortConfig inputs[] =
  625.                 {
  626.                         InputPortConfig<bool>("Enabled",                      false, "Enables node",                         "Enabled"),
  627.                         InputPortConfig<bool>("Disabled",                     true,  "Disables node",                        "Disabled"),
  628.                         InputPortConfig<float>("RainDrops_Amount",            0.0f,  "Sets rain drops visibility",           "Amount"),
  629.                         InputPortConfig<float>("RainDrops_SpawnTimeDistance", 0.35f, "Sets rain drops spawn time distance",  "Spawn Time Distance"),
  630.                         InputPortConfig<float>("RainDrops_Size",              5.0f,  "Sets rain drops size",                 "Size"),
  631.                         InputPortConfig<float>("RainDrops_SizeVariation",     2.5f,  "Sets rain drops size variation",       "Size Variation"),
  632.  
  633.                         InputPortConfig<float>("Moisture_Amount",             0.0f,  "Sets moisture visibility/area size",   "Moisture Amount"),
  634.                         InputPortConfig<float>("Moisture_Hardness",           10.0f, "Sets noise texture blending factor",   "Moisture Hardness"),
  635.                         InputPortConfig<float>("Moisture_DropletAmount",      7.0f,  "Sets droplet texture blending factor", "Moisture Droplet Amount"),
  636.                         InputPortConfig<float>("Moisture_Variation",          0.2f,  "Sets moisture variation",              "Moisture Variation"),
  637.                         InputPortConfig<float>("Moisture_Speed",              1.0f,  "Sets moisture animation speed",        "Moisture Speed"),
  638.                         InputPortConfig<float>("Moisture_FogAmount",          1.0f,  "Sets amount of fog in moisture",       "Moisture Fog Amount"),
  639.  
  640.                         { 0 }
  641.                 };
  642.  
  643.                 static const SOutputPortConfig outputs[] =
  644.                 {
  645.                         { 0 }
  646.                 };
  647.  
  648.                 config.nFlags |= EFLN_TARGET_ENTITY;
  649.                 config.pInputPorts = inputs;
  650.                 config.pOutputPorts = outputs;
  651.                 config.sDescription = _HELP("Rain drops effect");
  652.         }
  653.  
  654.         static void Disable()
  655.         {
  656.                 gEnv->p3DEngine->SetPostEffectParam("RainDrops_Amount", 0);
  657.                 gEnv->p3DEngine->SetPostEffectParam("Moisture_Amount", 0);
  658.         }
  659.  
  660.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  661.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  662. };
  663.  
  664. struct SEffectVolumetricScattering
  665. {
  666.         static void GetConfiguration(SFlowNodeConfig& config)
  667.         {
  668.                 static const SInputPortConfig inputs[] =
  669.                 {
  670.                         InputPortConfig<bool>("Enabled",                        false,     "Enables node",                               "Enabled"),
  671.                         InputPortConfig<bool>("Disabled",                       true,      "Disables node",                              "Disabled"),
  672.                         InputPortConfig<float>("VolumetricScattering_Amount",   0.0f,      "Sets volumetric scattering amount",          "Amount"),
  673.                         InputPortConfig<float>("VolumetricScattering_Tilling",  1.0f,      "Sets volumetric scattering tilling",         "Tilling"),
  674.                         InputPortConfig<float>("VolumetricScattering_Speed",    1.0f,      "Sets volumetric scattering animation speed", "Speed"),
  675.                         InputPortConfig<Vec3>("clr_VolumetricScattering_Color", Vec3(0.6f, 0.75f,                                        1.0f),      "Sets volumetric scattering amount","Color"),
  676.                         InputPortConfig<int>("VolumetricScattering_Type",       0,         "Set volumetric scattering type",             "Type"),
  677.                         { 0 }
  678.                 };
  679.  
  680.                 static const SOutputPortConfig outputs[] =
  681.                 {
  682.                         { 0 }
  683.                 };
  684.  
  685.                 config.nFlags |= EFLN_TARGET_ENTITY;
  686.                 config.pInputPorts = inputs;
  687.                 config.pOutputPorts = outputs;
  688.                 config.sDescription = _HELP("Volumetric scattering effect");
  689.         }
  690.  
  691.         static void Disable()
  692.         {
  693.                 gEnv->p3DEngine->SetPostEffectParam("VolumetricScattering_Amount", 0);
  694.         }
  695.  
  696.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  697.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  698. };
  699.  
  700. struct SEffect3DHudInterference
  701. {
  702.         static void GetConfiguration(SFlowNodeConfig& config)
  703.         {
  704.                 static const SInputPortConfig inputs[] =
  705.                 {
  706.                         InputPortConfig<bool>("Enabled",                        false,      "Enables node",                                                                                                                 "Enabled"),
  707.                         InputPortConfig<bool>("Disabled",                       true,       "Disables node",                                                                                                                "Disabled"),
  708.                         InputPortConfig<float>("Amount",                        0.0f,       "Sets 3D Hud inteference amount [0-1]",                                                                                         "Amount"),
  709.                         InputPortConfig<float>("DistruptScale",                 0.3f,       "Sets 3D Hud interference distruption scale [0-1]",                                                                             "Distrupt scale"),
  710.                         InputPortConfig<float>("DistruptMovementScale",         1.0f,       "Sets 3D Hud interference distruption movement scale [0-1]",                                                                    "Distrupt movement scale"),
  711.                         InputPortConfig<float>("RandomGrainStrengthScale",      0.3f,       "Sets 3D Hud interference random grain strength scale [0-1]",                                                                   "Random grain strength scale"),
  712.                         InputPortConfig<float>("RandomFadeStrengthScale",       0.4f,       "Sets 3D Hud interference random fade strength scale [0-1]",                                                                    "Random fade strength scale"),
  713.                         InputPortConfig<float>("NoiseStrength",                 0.2f,       "Sets 3D Hud interference noise strength [0-1]",                                                                                "Noise strength"),
  714.                         InputPortConfig<float>("ChromaShiftDistance",           1.0f,       "Sets 3D Hud interference chroma shift distance [0-1]",                                                                         "Chroma shift dist"),
  715.                         InputPortConfig<float>("ChromaShiftStrength",           0.25f,      "Sets 3D Hud interference chroma shift strength [0-1]",                                                                         "Chroma shift strength"),
  716.                         InputPortConfig<float>("RandFrequency",                 0.055f,     "Sets 3D Hud interference random number generation frequency [0-1]",                                                            "Rand frequency"),
  717.                         InputPortConfig<float>("ItemFilterStrength",            0.0f,       "Sets 3D Hud interference item filter strength (uses red channel in vertex color to control item interference strength) [0-1]", "Item filter strength"),
  718.                         InputPortConfig<float>("DofInterferenceStrength",       0.8f,       "Sets 3D Hud interference Depth of Field strength [0-1]",                                                                       "Depth of Field strength"),
  719.                         InputPortConfig<float>("BarScale",                      0.8f,       "Sets 3D Hud interference bar scale [0-1]",                                                                                     "Bar scale"),
  720.                         InputPortConfig<float>("BarColorMultiplier",            5.0f,       "Sets 3D Hud interference bar color multiplier [0-20]",                                                                         "Bar Color Multiplier"),
  721.                         InputPortConfig<Vec3>("clr_3DHudInterference_BarColor", Vec3(0.39f, 0.6f,                                                                                                                           1.0f),                         "Sets 3D Hud interference bar color","Bar Color"),
  722.                         { 0 }
  723.                 };
  724.  
  725.                 static const SOutputPortConfig outputs[] =
  726.                 {
  727.                         { 0 }
  728.                 };
  729.  
  730.                 config.nFlags |= EFLN_TARGET_ENTITY;
  731.                 config.pInputPorts = inputs;
  732.                 config.pOutputPorts = outputs;
  733.                 config.sDescription = _HELP("3D Hud interference effect");
  734.         }
  735.  
  736.         static void Disable()
  737.         {
  738.                 gEnv->p3DEngine->SetPostEffectParam("HUD3D_Interference", 0.0f);
  739.         }
  740.  
  741.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo)
  742.         {
  743.                 if (pFlowBaseNode && pActInfo)
  744.                 {
  745.                         bool isOk = true;
  746.  
  747.                         float interferenceScale = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 2, isOk);
  748.                         float disruptScale = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 3, isOk);
  749.                         float disruptMovementScale = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 4, isOk);
  750.                         float randomGrainStrengthScale = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 5, isOk);
  751.                         float randomFadeStrengthScale = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 6, isOk);
  752.                         float noiseStrength = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 7, isOk);
  753.                         float chromaShiftDist = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 8, isOk);
  754.                         float chromaShiftStrength = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 9, isOk);
  755.                         float randFrequency = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 10, isOk);
  756.                         float itemOverrideStrength = 1.0f - GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 11, isOk);
  757.                         float depthOfFieldStrength = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 12, isOk);
  758.                         float barScale = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 13, isOk);
  759.                         float barColorMultiplier = GetCustomValue(config, pFlowBaseNode, bIsEnabled, pActInfo, 14, isOk);
  760.  
  761.                         Vec3 barColor;
  762.                         GetCustomValueVec3(barColor, config, pFlowBaseNode, bIsEnabled, pActInfo, 15, isOk);
  763.  
  764.                         if (isOk)
  765.                         {
  766.                                 I3DEngine* p3DEngine = gEnv->p3DEngine;
  767.                                 p3DEngine->SetPostEffectParam("HUD3D_Interference", interferenceScale);
  768.                                 p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams0", Vec4(itemOverrideStrength, randFrequency, depthOfFieldStrength, 0.0f), true);
  769.                                 p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams1", Vec4(randomGrainStrengthScale, randomFadeStrengthScale, chromaShiftStrength, chromaShiftDist), true);
  770.                                 p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams2", Vec4(disruptScale, disruptMovementScale, noiseStrength, barScale), true);
  771.                                 p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams3", Vec4(barColor.x, barColor.y, barColor.z, barColorMultiplier), true);
  772.                         }
  773.                 }
  774.  
  775.                 return true;
  776.         }
  777.  
  778.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)
  779.         {
  780.                 //CRY_TODO(11, 1, 2010, "make a propper serialization here");
  781.                 if (ser.IsReading())
  782.                 {
  783.                         float interferenceScale = 0.0f;
  784.                         float disruptScale = 0.3f;
  785.                         float disruptMovementScale = 1.0f;
  786.                         float randomGrainStrengthScale = 0.3f;
  787.                         float randomFadeStrengthScale = 0.4f;
  788.                         float noiseStrength = 0.2f;
  789.                         float chromaShiftDist = 1.0f;
  790.                         float chromaShiftStrength = 0.25f;
  791.                         float randFrequency = 0.055f;
  792.                         float itemOverrideStrength = 0.0f;
  793.                         float depthOfFieldStrength = 0.8f;
  794.                         float barScale = 0.8f;
  795.                         float barColorMultiplier = 5.0f;
  796.                         Vec3 barColor(0.39f, 0.6f, 1.0f);
  797.  
  798.                         I3DEngine* p3DEngine = gEnv->p3DEngine;
  799.                         p3DEngine->SetPostEffectParam("HUD3D_Interference", interferenceScale);
  800.                         p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams0", Vec4(itemOverrideStrength, randFrequency, depthOfFieldStrength, 0.0f), true);
  801.                         p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams1", Vec4(randomGrainStrengthScale, randomFadeStrengthScale, chromaShiftStrength, chromaShiftDist), true);
  802.                         p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams2", Vec4(disruptScale, disruptMovementScale, noiseStrength, barScale), true);
  803.                         p3DEngine->SetPostEffectParamVec4("HUD3D_InterferenceParams3", Vec4(barColor.x, barColor.y, barColor.z, barColorMultiplier), true);
  804.                 }
  805.         }
  806. };
  807.  
  808. struct SEffectGhosting
  809. {
  810.         static void GetConfiguration(SFlowNodeConfig& config)
  811.         {
  812.                 static const SInputPortConfig inputs[] =
  813.                 {
  814.                         InputPortConfig<bool>("Enabled",               false, "Enables node",            "Enabled"),
  815.                         InputPortConfig<bool>("Disabled",              true,  "Disables node",           "Disabled"),
  816.                         InputPortConfig<float>("ImageGhosting_Amount", 0.0f,  "Enables ghosting effect", "GhostingAmount"),
  817.                         { 0 }
  818.                 };
  819.  
  820.                 static const SOutputPortConfig outputs[] =
  821.                 {
  822.                         { 0 }
  823.                 };
  824.  
  825.                 config.nFlags |= EFLN_TARGET_ENTITY;
  826.                 config.pInputPorts = inputs;
  827.                 config.pOutputPorts = outputs;
  828.                 config.sDescription = _HELP("Ghosting effect");
  829.         }
  830.  
  831.         static void Disable()
  832.         {
  833.                 gEnv->p3DEngine->SetPostEffectParam("ImageGhosting_Amount", 0.0f);
  834.         }
  835.  
  836.         static bool CustomSetData(const SFlowNodeConfig& config, TBaseNodeClass* pFlowBaseNode, bool bIsEnabled, IFlowNode::SActivationInfo* pActInfo) { return false; }
  837.         static void Serialize(IFlowNode::SActivationInfo* pActInfo, TSerialize ser)                                                                    {}
  838. };
  839. //////////////////////////////////////////////////////////////////////////
  840.  
  841. template<class T>
  842. class CFlowImageNode : public TBaseNodeClass
  843. {
  844. public:
  845.         CFlowImageNode(SActivationInfo* pActInfo)
  846.         {
  847.         }
  848.  
  849.         ~CFlowImageNode()
  850.         {
  851.         }
  852.  
  853.         /* It's now a singleton node, so clone MUST not be implemented
  854.            IFlowNodePtr Clone( SActivationInfo * pActInfo )
  855.            {
  856.            return this;
  857.            }
  858.          */
  859.  
  860.         enum EInputPorts
  861.         {
  862.                 EIP_Enabled = 0,
  863.                 EIP_Disabled
  864.         };
  865.  
  866.         virtual void GetConfiguration(SFlowNodeConfig& config)
  867.         {
  868.                 T::GetConfiguration(config);
  869.                 if (!(config.nFlags & EFLN_OBSOLETE))
  870.                         config.SetCategory(EFLN_ADVANCED);
  871.         }
  872.  
  873.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  874.         {
  875.                 if (event != eFE_Activate)
  876.                 {
  877.                         return;
  878.                 }
  879.  
  880.                 if (pActInfo->pEntity)
  881.                 {
  882.                         if (!InputEntityIsLocalPlayer(pActInfo))
  883.                         {
  884.                                 return;
  885.                         }
  886.                 }
  887.                 else
  888.                 {
  889.                         if (!gEnv->IsClient())
  890.                         {
  891.                                 return;
  892.                         }
  893.                 }
  894.  
  895.                 bool bIsEnabled = IsPortActive(pActInfo, EIP_Enabled) && GetPortBool(pActInfo, EIP_Enabled);
  896.                 const bool bIsDisabled = IsPortActive(pActInfo, EIP_Disabled) && GetPortBool(pActInfo, EIP_Disabled);
  897.  
  898.                 if (!bIsDisabled && GetPortBool(pActInfo, EIP_Enabled))    // this is to support when effects parameters are changed after the effect was activated. would be easier to just make sure that the bool value of both inputs is always complementary, but that conflicts on how triggers work, and other nodes already rely on that way of working.
  899.                         bIsEnabled = true;
  900.  
  901.                 if (!bIsEnabled)
  902.                 {
  903.                         T::Disable();
  904.                         return;
  905.                 }
  906.  
  907.                 SFlowNodeConfig config;
  908.                 T::GetConfiguration(config);
  909.                 if (T::CustomSetData(config, this, bIsEnabled, pActInfo) == false)
  910.                 {
  911.                         I3DEngine* pEngine = gEnv->p3DEngine;
  912.  
  913.                         for (int i(2); config.pInputPorts[i].name; ++i)
  914.                         {
  915.                                 const TFlowInputData& anyVal = GetPortAny(pActInfo, i);
  916.  
  917.                                 switch (anyVal.GetType())
  918.                                 {
  919.  
  920.                                 case eFDT_Vec3:
  921.                                         {
  922.                                                 Vec3 pVal(GetPortVec3(pActInfo, i));
  923.                                                 if (!bIsEnabled)
  924.                                                         config.pInputPorts[i].defaultData.GetValueWithConversion(pVal);
  925.                                                 pEngine->SetPostEffectParamVec4(config.pInputPorts[i].name, Vec4(pVal, 1));
  926.  
  927.                                                 break;
  928.                                         }
  929.  
  930.                                 case eFDT_String:
  931.                                         {
  932.                                                 const string& pszString = GetPortString(pActInfo, i);
  933.                                                 pEngine->SetPostEffectParamString(config.pInputPorts[i].name, pszString.c_str());
  934.  
  935.                                                 break;
  936.                                         }
  937.  
  938.                                 default:
  939.                                         {
  940.                                                 float fVal;
  941.                                                 bool ok(anyVal.GetValueWithConversion(fVal));
  942.  
  943.                                                 if (!bIsEnabled)
  944.                                                         ok = config.pInputPorts[i].defaultData.GetValueWithConversion(fVal);
  945.  
  946.                                                 if (ok)
  947.                                                 {
  948.                                                         pEngine->SetPostEffectParam(config.pInputPorts[i].name, fVal);
  949.                                                 }
  950.  
  951.                                                 break;
  952.                                         }
  953.                                 }
  954.                         }
  955.                 }
  956.         }
  957.  
  958.         virtual void GetMemoryUsage(ICrySizer* s) const
  959.         {
  960.                 s->Add(*this);
  961.         }
  962.  
  963.         virtual void Serialize(IFlowNode::SActivationInfo* actInfo, TSerialize ser)
  964.         {
  965.                 T::Serialize(actInfo, ser);
  966.         }
  967. };
  968.  
  969. //////////////////////////////////////////////////////////////////////////////////////
  970.  
  971. class CFlowNode_SetShadowMode : public CFlowBaseNode<eNCT_Singleton>
  972. {
  973. public:
  974.         CFlowNode_SetShadowMode(SActivationInfo* pActInfo)
  975.         {
  976.         }
  977.  
  978.         virtual void GetMemoryUsage(ICrySizer* s) const
  979.         {
  980.                 s->Add(*this);
  981.         }
  982.  
  983.         enum EInputs
  984.         {
  985.                 eIn_Activate = 0,
  986.                 eIn_Mode
  987.         };
  988.  
  989.         void GetConfiguration(SFlowNodeConfig& config)
  990.         {
  991.                 static const SInputPortConfig in_config[] =
  992.                 {
  993.                         InputPortConfig_Void("Activate",   _HELP("Sets the specified shadow mode")),
  994.                         InputPortConfig<int>("ShadowMode", 0,                                       _HELP("Shadow mode"),_HELP("ShadowMode"), _UICONFIG("enum_int:Normal=0,HighQuality=1")), // the values needs to coincide with EShadowMode
  995.                         { 0 }
  996.                 };
  997.  
  998.                 static const SOutputPortConfig out_config[] = {
  999.                         { 0 }
  1000.                 };
  1001.  
  1002.                 config.pInputPorts = in_config;
  1003.                 config.pOutputPorts = out_config;
  1004.                 config.sDescription = _HELP("Sets a shadow mode for the 3dengine");
  1005.                 config.SetCategory(EFLN_APPROVED);
  1006.         }
  1007.  
  1008.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1009.         {
  1010.                 switch (event)
  1011.                 {
  1012.                 case eFE_Activate:
  1013.                         {
  1014.                                 if (IsPortActive(pActInfo, eIn_Activate))
  1015.                                 {
  1016.                                         EShadowMode shadowMode = EShadowMode(GetPortInt(pActInfo, eIn_Mode));
  1017.                                         gEnv->p3DEngine->SetShadowMode(shadowMode);
  1018.                                 }
  1019.                         }
  1020.                         break;
  1021.                 }
  1022.         }
  1023. };
  1024.  
  1025. //////////////////////////////////////////////////////////////////////////
  1026. // these macros expose the nodes in the FlowSystem, otherwise they're not available in the system
  1027. REGISTER_FLOW_NODE_EX("Image:ColorCorrection", CFlowImageNode<SColorCorrection>, SColorCorrection);
  1028. REGISTER_FLOW_NODE_EX("Image:FilterBlur", CFlowImageNode<SFilterBlur>, SFilterBlur);
  1029. REGISTER_FLOW_NODE_EX("Image:FilterRadialBlur", CFlowImageNode<SFilterRadialBlur>, SFilterRadialBlur);
  1030. REGISTER_FLOW_NODE_EX("Image:FilterSharpen", CFlowImageNode<SFilterSharpen>, SFilterSharpen);
  1031. REGISTER_FLOW_NODE_EX("Image:FilterChromaShift", CFlowImageNode<SFilterChromaShift>, SFilterChromaShift);
  1032. REGISTER_FLOW_NODE_EX("Image:EffectFrost", CFlowImageNode<SEffectFrost>, SEffectFrost);
  1033. REGISTER_FLOW_NODE_EX("Image:FilterGrain", CFlowImageNode<SFilterGrain>, SFilterGrain);
  1034. REGISTER_FLOW_NODE_EX("Image:EffectWaterDroplets", CFlowImageNode<SEffectWaterDroplets>, SEffectWaterDroplets);
  1035. REGISTER_FLOW_NODE_EX("Image:EffectWaterFlow", CFlowImageNode<SEffectWaterFlow>, SEffectWaterFlow);
  1036. REGISTER_FLOW_NODE_EX("Image:EffectBloodSplats", CFlowImageNode<SEffectBloodSplats>, SEffectBloodSplats);
  1037. REGISTER_FLOW_NODE_EX("Image:EffectGhosting", CFlowImageNode<SEffectGhosting>, SEffectGhosting);
  1038. REGISTER_FLOW_NODE_EX("Image:EffectGhostVision", CFlowImageNode<SEffectGhostVision>, SEffectGhostVision);
  1039. REGISTER_FLOW_NODE_EX("Image:EffectDepthOfField", CFlowImageNode<SEffectDof>, SEffectDof);
  1040. REGISTER_FLOW_NODE_EX("Image:EffectVolumetricScattering", CFlowImageNode<SEffectVolumetricScattering>, SEffectVolumetricScattering);
  1041. REGISTER_FLOW_NODE_EX("Image:FilterDirectionalBlur", CFlowImageNode<SEffectDirectionalBlur>, SEffectDirectionalBlur);
  1042. REGISTER_FLOW_NODE_EX("Image:EffectAlienInterference", CFlowImageNode<SEffectAlienInterference>, SEffectAlienInterference);
  1043. REGISTER_FLOW_NODE_EX("Image:EffectRainDrops", CFlowImageNode<SEffectRainDrops>, SEffectRainDrops);
  1044. REGISTER_FLOW_NODE_EX("Image:FilterVisualArtifacts", CFlowImageNode<SFilterVisualArtifacts>, SFilterVisualArtifacts);
  1045. REGISTER_FLOW_NODE_EX("Image:3DHudInterference", CFlowImageNode<SEffect3DHudInterference>, SEffect3DHudInterference);
  1046. REGISTER_FLOW_NODE("Image:SetShadowMode", CFlowNode_SetShadowMode);
  1047.  
downloadFlowEngineEffectsNodes.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