virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig<bool>( "A",_HELP("out = A op B") ),
			InputPortConfig<bool>( "B",_HELP("out = A op B") ),
			InputPortConfig<bool>( "Always", _HELP("if true, the outputs will be activated every time an input is. If false, outputs only will be activated when the value does change") ),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<bool>("out",_HELP("out = A op B")),
			OutputPortConfig<bool>("true",_HELP("triggered if out is true")),
			OutputPortConfig<bool>("false",_HELP("triggered if out is false")),
			{0}
		};
		config.sDescription = _HELP( "Do logical operation on input ports and outputs result to [out] port. True port is triggered if the result was true, otherwise the false port is triggered." );
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
		config.SetCategory(EFLN_APPROVED);
	}

	void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = 
		{
			InputPortConfig<bool>("Enabled", true, _HELP("To enable/disable the node.")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig<int>("Awareness", _HELP("0-100")),
			OutputPortConfig_Void("green", _HELP("Awareness=0")),
			OutputPortConfig_Void("yellow", _HELP("Awareness between 0-50")),
			OutputPortConfig_Void("red",  _HELP("Awareness >50")),
			{0}
		};    

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Outputs a value that represents the AI enemy awareness of the player. This value closely matches the HUD alertness indicator. \nOutputs are triggered only when they change.");
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig<bool> ("Asian", false, _HELP("If true, use Asian material, otherwise US")),
			InputPortConfig_Void  ("Cloak", _HELP("Trigger to select Cloak Mode")),
			InputPortConfig_Void  ("Strength", _HELP("Trigger to select Strength Mode")),
			InputPortConfig_Void  ("Defense", _HELP("Trigger to select Defense Mode")),
			InputPortConfig_Void  ("Speed", _HELP("Trigger to select Speed Mode")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void("Done", _HELP("Triggered when Done.")),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Fake Materials on Characters (non Player/AI) NanoSuit for Cinematics");
		config.SetCategory(EFLN_WIP);
	}

	virtual void GetConfiguration(SFlowNodeConfig &config)
	{
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Get", _HELP("Get minimap info")),
			{0}
		};
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig_Void("OnGet",	_HELP("Tirggers of port <Get> is activeated")),
			OutputPortConfig<string>("MapFile",	_HELP("Name of minimap dds file")),
			OutputPortConfig<int>	("Width",		_HELP("Minimap width")),
			OutputPortConfig<int>	("Height",		_HELP("Minimap height")),
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Info about minimap");
		config.SetCategory(EFLN_ADVANCED);
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig  in_config[] = {
			InputPortConfig<Vec3>( "pos", "Input camera position." ),
			InputPortConfig<Vec3>( "dir", "Input camera direction." ),
			InputPortConfig<float>( "roll", "Input camera roll." ),
			InputPortConfig<bool>( "active", true, "While false, the node wont output any value" ),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<Vec3>("pos", "Current camera position."),
			OutputPortConfig<Vec3>("dir", "Current camera direction."),
			OutputPortConfig<float>("roll", "Current camera roll."),
			{0}
		};
		config.nFlags      |= EFLN_TARGET_ENTITY;
		config.pInputPorts  = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_OBSOLETE);
	}

  void GetConfiguration( SFlowNodeConfig& config )
  {
    static const SInputPortConfig in_ports[] = 
    {
      InputPortConfig_Void( "Activate", _HELP("Connect event here to remove all items from inventory" )),        
      {0}
    };

    static const SOutputPortConfig out_ports[] = 
    {
      OutputPortConfig<bool>("Done", _HELP("True when done successfully")),
      {0}
    };

		config.sDescription = _HELP("When activated, removes all items from inventory.");
		config.nFlags |= EFLN_TARGET_ENTITY;
    config.pInputPorts = in_ports;   
    config.pOutputPorts = out_ports;   
		config.SetCategory(EFLN_APPROVED);
  }

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Link", _HELP("Link the Player to Target Entity")),
			InputPortConfig_Void  ("Unlink", _HELP("Unlink the Player (from any Entity)")),
			InputPortConfig<EntityId> ("Target", _HELP("Target Entity Id") ),
			InputPortConfig<int>  ("DrawPlayer", 0, _HELP("Draw the Player (Hide=-1, NoChange=0, Show=1)"), 0, _UICONFIG("enum_int:NoChange=0,Hide=-1,Show=1")),
			InputPortConfig<bool> ("KeepTransformationOnUnlink", true, _HELP("Keep Transformation on Unlink")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void ("Linked", _HELP("Trigger if Linked")),
			OutputPortConfig_Void ("Unlinked", _HELP("Trigger if Unlinked")),
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Linking the Player to an Entity (with FreeLook)");
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = 
		{
			InputPortConfig_Void   ( "Trigger", _HELP("show debug informations on screen") ),
			InputPortConfig<float> ( "Size", 1.5f, _HELP("font size")),
			InputPortConfig<string>( "vehicleParts_Parts", _HELP("select vehicle parts"), 0, _UICONFIG("ref_entity=entityId") ),
			{0}
		};

		static const SOutputPortConfig out_config[] = 
		{
			{0}
		};

		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_DEBUG);
	}

 virtual void GetConfiguration(SFlowNodeConfig& config)
 {
     static const SInputPortConfig in_config[] =
     {
         InputPortConfig_AnyType("Check", _HELP("Triggers a check of the current input control scheme")),
         {0}
     };
     static const SOutputPortConfig out_config[] =
     {
         OutputPortConfig_AnyType("Keyboard", _HELP("Outputs the signal from Check input if the current control scheme is keyboard (Focus on keyboard")),
         OutputPortConfig_AnyType("KeyboardMouse", _HELP("Outputs the signal from Check input if the current control scheme is keyboardmouse (Focus on mouse with keyboard")),
         OutputPortConfig_AnyType("XBoxOneController", _HELP("Outputs the signal from Check input if the current control scheme is XBoxOne controller")),
         OutputPortConfig_AnyType("PS4Controller", _HELP("Outputs the signal from Check input if the current control scheme is PS4 controller")),
         {0}
     };
     config.sDescription = _HELP("Provides branching logic for different input control schemes");
     config.pInputPorts = in_config;
     config.pOutputPorts = out_config;
     config.SetCategory(EFLN_APPROVED);
 }

void CFlashUIInventoryNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig_Void( "Call", "Calls the function" ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnCall", "Triggered if this node starts the action" ),
		OutputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};


	config.nFlags |= EFLN_TARGET_ENTITY;
	config.pInputPorts = in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Outputs the players inventory as a string for UI processing";
	config.SetCategory(EFLN_APPROVED);
}

// --------------------------------------------------------------
void CFlashUIFromArrayExNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig_Void( "Get", "Get the value at \"Index\""),
		InputPortConfig<string>( "Array", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
		InputPortConfig<int>( "Index", "Index" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_AnyType( "Value", "Value of element at \"Index\"" ),
		{0}
	};

	config.pInputPorts  = in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Get specific Value from UI Array";
	config.SetCategory(EFLN_APPROVED);
}

//------------------------------------------------------------------------------------------------------
void CFlashUIPlatformNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig_Void( "get", "Get current platform" ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "IsPc",   _HELP("Triggered on PC")),
		OutputPortConfig_Void( "IsXBoxOne",  _HELP("Triggered on XBox One")),
		OutputPortConfig_Void( "IsPS4",  _HELP("Triggered on PS4")),
		OutputPortConfig_Void( "IsConsole", _HELP("Triggered on Consoles") ),
		{0}
	};

	config.sDescription = "Node to get current platform, works also with selected platform of UIEmulator";
	config.pInputPorts = in_config;
	config.pOutputPorts = out_config;
	config.SetCategory( EFLN_APPROVED );
}

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig_Void( "Check", _HELP("Trigger this port to check if Actor's current weapon is zoomed" )),
			InputPortConfig<string>( "Weapon", _HELP("Name of Weapon to check. Empty=All."), 0, _UICONFIG("enum_global:weapon")),
			{0}
		};
		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig_Void( "False", _HELP("Triggered if weapon is not zoomed.")),
			OutputPortConfig_Void( "True",  _HELP("Triggered if weapon is zoomed.")),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.sDescription = _HELP("Checks if target actor's current weapon is zoomed.");
		config.SetCategory(EFLN_WIP);
	}

	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig<int>("Id", 0, _HELP("Id for the container")),
			InputPortConfig_Void("Start",_HELP("Start iterating")),
			{0}
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig<int>("Error", _HELP("the number specifies the error - 1: containerId is invalid")),
			OutputPortConfig_Void("Done", _HELP("Operation successfully completed")),
			OutputPortConfig_AnyType("Out", _HELP("Value from the container")),
			{0}
		};

		config.sDescription = _HELP("This node is used to iterator over containers");
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.SetCategory(EFLN_APPROVED);
	}

    virtual void GetConfiguration( SFlowNodeConfig& config )
    {
        static const SInputPortConfig inPorts[] =
        {
            InputPortConfig_Void( "Enable" ),
            InputPortConfig_Void( "Disable" ),
            { 0 }
        };

        static const SOutputPortConfig outPorts[] =
        {
            { 0 }
        };

        config.pInputPorts = inPorts;
        config.pOutputPorts = outPorts;
        config.nFlags |= EFLN_TARGET_ENTITY;
        config.sDescription = _HELP( "When enabled, combat mode changes the behaviour from trying to strictly follow paths to trying to find the best position in the path from where to engage the target. The default state is disabled." );
        config.SetCategory( EFLN_APPROVED );
    }

	VIRTUAL void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = 
		{
			InputPortConfig<string>("audioRTPC_Name", _HELP("RTPC name"), "Name"),
			InputPortConfig<float>("value", _HELP("RTPC value"), "Value"),
			{0}
		};

		static const SOutputPortConfig outputs[] = 
		{
			{0}
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("This node sets RTPC values.");
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.SetCategory(EFLN_APPROVED);
	}

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig_Void("Get", _HELP("Get the current Latitude/Longitude")),
			InputPortConfig_Void("Set", _HELP("Set the Latitude/Longitude")),
			InputPortConfig<float>("Latitude",  0.0f, _HELP("Latitude to be set")),
			InputPortConfig<float>("Longitude", 35.0f, _HELP("Longitude to be set")),
			InputPortConfig<bool>("ForceUpdate", false, _HELP("Force Immediate Update of Sky if true. USE ONLY IN SPECIAL CASES, is heavy on performance!") ),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<float>("Latitude", _HELP("Current Latitude")),
			OutputPortConfig<float>("Longitude", _HELP("Current Longitude")),
			{0}
		};
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.sDescription = _HELP("Set the 3DEngine's Moon Direction");
		config.SetCategory(EFLN_APPROVED);
	}

  virtual void GetConfiguration(SFlowNodeConfig& config)
  {
    static const SInputPortConfig inputs[] = {      
      InputPortConfig<EntityId>("objectId", _HELP("Entity to grab")),
      InputPortConfig_Void("grab", _HELP("Pulse this to grab object.")),
      InputPortConfig_Void("drop", _HELP("Pulse this to drop currently grabbed object.")),
      InputPortConfig<bool>("throw", _HELP("If true, object is thrown forward.")),
      {0}
    };
    static const SOutputPortConfig outputs[] = {
      OutputPortConfig<bool>("success", _HELP("true if object was grabbed/dropped successfully")),
      OutputPortConfig<EntityId>("grabbedObjId", _HELP("Currently grabbed object, or 0")),
      {0}
    };    
    config.pInputPorts = inputs;
    config.pOutputPorts = outputs;
    config.nFlags |= EFLN_TARGET_ENTITY;
    config.sDescription = _HELP("Target entity will try to grab the input object, respectively drop/throw its currently grabbed object.");
		config.SetCategory(EFLN_APPROVED);
  }

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void("Poll", _HELP("Poll party info")),
			InputPortConfig_Void("Launch", _HELP("Launch match")),
			InputPortConfig_Void("Leave", _HELP("Launch match")),
			{0}
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void     ("Success",  _HELP("Triggers if sending succeeded")),
			OutputPortConfig_Void     ("Fail",  _HELP("Triggers if sending failed")),
			{0}
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("poll party info for xbox one live");
		config.SetCategory(EFLN_ADVANCED);
	}

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig_Void("Set", _HELP("Sets the param")),
			InputPortConfig<string>("ParamName", _HELP("Parameter name")),
			InputPortConfig<float> ("ParamFloat", 0, _HELP("Parameter type in float")),
			{0}
		};

		static const SOutputPortConfig out_ports[] =
		{
			OutputPortConfig_Void( "Set", _HELP("Triggers when param set")),
			{0}
		};

		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.sDescription = _HELP("Sets post effect param by name");
		config.SetCategory(EFLN_DEBUG);
	}