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"), 0, _UICONFIG("enum_int:NoChange=0,Hide=-1,Show=1") ),
			InputPortConfig<bool> ("KeepTransfromDetach", true, _HELP("Keep Transformation on Detach")),
			{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 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);
	}

	virtual void GetConfiguration(SFlowNodeConfig &config)
	{
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Freeze", _HELP("Trigger to freeze entity")),
			InputPortConfig_Void("UnFreeze", _HELP("Trigger to un-freeze entity")),
			InputPortConfig<bool> ("UseVapor", true, _HELP("Trigger to un-freeze entity")),
			{0}
		};
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig_Void("Frozen",   _HELP("Triggered on Freeze")),
			OutputPortConfig_Void("UnFrozen", _HELP("Triggered on UnFreeze")),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Freezes/Unfreezes attached entity/actor.");
		config.SetCategory(EFLN_ADVANCED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Enable"       , _HELP("")),
			InputPortConfig_Void  ("Disable"      , _HELP("")),
			InputPortConfig<float>("MinDamping"   ,  50.f, _HELP("Minimum Damping of walk speed")),
			InputPortConfig<float>("MaxDamping"   ,  75.f, _HELP("Maximum Damping of walk speed")),
			InputPortConfig<float>("PeriodicTime" ,   4.f, _HELP("Time in seconds for one stumble")),
			InputPortConfig<float>("StrengthX"    , 100.f, _HELP("Stumble strength in X direction")),
      InputPortConfig<float>("StrengthY"    , 100.f, _HELP("Stumble strength in Y direction") ),
      InputPortConfig<float>("Randomness"   ,   0.f, _HELP("Value in [0,2]. Higher value means more variation.") ),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Activates the player beeing like drunken.");
		config.SetCategory(EFLN_APPROVED);
	}

void CFlashUIMCTemplateRemoveNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		CreateElementsPort(),
		CreateInstanceIdPort(),
		CreateTmplInstanceNamePort(),
		InputPortConfig_Void( "Remove", "Removes the given MovieClip" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnRemove", "Triggered once the MovieClip was removed" ),
		{0}
	};

	config.pInputPorts  =  in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Removes a MovieClip";
	config.SetCategory(EFLN_APPROVED);
}

// --------------------------------------------------------------
void CFlashUIArrayConcatNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig_Void( "Merge", "Merge the arrays"),
		InputPortConfig<string>( "Array1", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
		InputPortConfig<string>( "Array2", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnMerge", "On merged the arrays" ),
		OutputPortConfig<string>( "Array", UIARGS_DEFAULT_DELIMITER_NAME " separated list" ),
		{0}
	};

	config.pInputPorts  = in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Merge two Arrays";
	config.SetCategory(EFLN_APPROVED);
}

void CFlowLogNode::GetConfiguration( SFlowNodeConfig& config )
{
    static const SInputPortConfig inconfig[] = {
        InputPortConfig_Void("input"),
        InputPortConfig<string>("message", "no message set"),
        {0}
    };

    config.pInputPorts = inconfig;
    config.pOutputPorts = NULL;
    config.SetCategory(EFLN_DEBUG);
}

void CFlashUIVariableBaseNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		CreateVariablesPort(),
		CreateInstanceIdPort(),
		InputPortConfig_Void( "Set", "Set value" ),
		InputPortConfig_Void( "Get", "Get value" ),
		InputPortConfig_AnyType( "Value", "Value to set" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SInputPortConfig in_config_tmpl[] = {
		CreateVariablesForTmplPort(),
		CreateInstanceIdPort(),
		CreateTmplInstanceNamePort(),
		InputPortConfig_Void( "Set", "Set value" ),
		InputPortConfig_Void( "Get", "Get value" ),
		InputPortConfig_AnyType( "Value", "Value to set" ),
		InputPortConfig_Void( 0 ),
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnSet", "On set value" ),
		OutputPortConfig_AnyType( "Value", "Value" ),
		{0}
	};

	config.pInputPorts  =  IsTemplate() ? in_config_tmpl : in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Access to Variables";
	config.SetCategory(EFLN_APPROVED);
}

void CFlashUIGotoAndPlayBaseNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		CreateMovieClipsPort(),
		CreateInstanceIdPort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SInputPortConfig in_config_tmpl[] = {
		CreateMovieClipsForTmplPort(),
		CreateInstanceIdPort(),
		CreateTmplInstanceNamePort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnGotoAndPlay", "On GotoAndPlay" ),
		OutputPortConfig_Void( "OnGotoAndStop", "On GotoAndStop" ),
		{0}
	};

	config.pInputPorts  =  IsTemplate() ? in_config_tmpl : in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Access to MovieClips";
	config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			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")),
			InputPortConfig<float>("Energy", 0.0f, _HELP("Set Energy")),
			InputPortConfig<int>  ("CloakLevel", 1, _HELP("Set cloak level [1-3]")),
			InputPortConfig_Void  ("BreakHUD", _HELP("Trigger to break the HUD, causing it to disappear")),
			InputPortConfig_Void  ("RebootHUD", _HELP("Trigger to reboot the HUD, causing it to appear")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("Cloak", _HELP("Triggered on Default Mode")),
			OutputPortConfig_Void  ("Strength", _HELP("Triggered on Strength Mode")),
			OutputPortConfig_Void  ("Defense", _HELP("Triggered on Defense Mode")),
			OutputPortConfig_Void  ("Speed", _HELP("Triggered on Speed Mode")),
			OutputPortConfig<float>("Energy", _HELP("Current Energy")),
			OutputPortConfig<int>  ("CloakLevel", _HELP("Current cloak level [set when Cloak mode is active]")),
			// OutputPortConfig_Void  ("BreakHUD", "Triggered on breaking the HUD"),
			// OutputPortConfig_Void  ("RebootHUD", "Triggered on rebooting the HUD"),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("NanoSuit Node");
		config.SetCategory(EFLN_WIP);
	}

void CFlowSetupModelPostRender::GetConfiguration(SFlowNodeConfig& config)
{
	static const SInputPortConfig inputs[] = {
		InputPortConfig_Void("Start", _HELP("Start rendering")),
		InputPortConfig_Void("Shutdown", _HELP("Shutdown")),
		InputPortConfig<string>( "uiMovieclips_MovieClip",_HELP("MovieClip to attach the texture to") ),
		InputPortConfig<Vec3>( "AmbientLightColor",_HELP("") ),
		InputPortConfig<float>( "AmbientLightStrength", 0.8f, _HELP("") ),
		InputPortConfig<Vec3>( "LightColor1", Vec3(5.f, 6.f, 5.5f), _HELP("") ),
		InputPortConfig<Vec3>( "LightColor2", Vec3(0.7f, 0.7f, 0.7f), _HELP("") ),
		InputPortConfig<Vec3>( "LightColor3", Vec3(0.5f, 1.0f, 0.7f), _HELP("") ),
		InputPortConfig<float>( "DebugScale", 0.0f, _HELP("0 = off, otherwise 0 - 1 to visualize the debugview with UVmap") ),
		{0}
	};
	static const SOutputPortConfig outputs[] = {
		{0}
	};    
	config.pInputPorts = inputs;
	config.pOutputPorts = outputs;
	config.sDescription = _HELP("Add 3d model to HUD RT");
	config.SetCategory(EFLN_APPROVED);
}

void CFlowNode_AICorpses::GetConfiguration( SFlowNodeConfig& config )
{
	static const SInputPortConfig inp_config[] = 
	{
		InputPortConfig_Void("CleanCorpses", _HELP("Removes all corpses in the level")),
		{0}
	};

	config.sDescription = _HELP( "AI corpse management" );
	config.pInputPorts = inp_config;
	config.pOutputPorts = NULL;
	config.SetCategory(EFLN_APPROVED);
}

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig_Void( "Attach", _HELP("Trigger to attach accessory on the Actor's weapon" )),
			InputPortConfig_Void( "Detach", _HELP("Trigger to detach accessory from the Actor's weapon" )),
			InputPortConfig<string>( "Weapon", _HELP("Name of weapon the accessory should be attached/detached"), 0, _UICONFIG("enum_global:weapon")),
			InputPortConfig<string>( "Accessory", _HELP("Name of accessory"), 0, _UICONFIG("enum_global:item")),
			{0}
		};
		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig_Void( "Attached", _HELP("Triggered if accessory was attached.")),
			OutputPortConfig_Void( "Detached",  _HELP("Triggered if accessory was detached.")),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.sDescription = _HELP("Attach/Detach [Accessory] from Actor's weapon [Weapon]. Both must be in the Inventory.");
		config.SetCategory(EFLN_WIP);
	}

void ClearAssignmentFlowNode::GetConfiguration( SFlowNodeConfig& config )
{
	static const SInputPortConfig inputPortConfig[] = 
	{
		InputPortConfig_Void("Set"),
		{0}
	};

	config.pInputPorts = inputPortConfig;
	config.sDescription = _HELP("Removes the active assignment. Usable by: All");
	config.nFlags |= EFLN_TARGET_ENTITY;
	config.SetCategory(EFLN_APPROVED);
}

//------------------------------------------------------------------------------------------------------
void CFlashUIConstraintsNode::GetConfiguration( SFlowNodeConfig &config )
{
    static const SInputPortConfig in_config[] = {
        CreateElementsPort(),
        CreateInstanceIdPort(),
        InputPortConfig_Void( "set", "Set configuration" ),
        InputPortConfig_Void( "get", "Get configuration" ),
        InputPortConfig<int>( "type", 1, _HELP( "Set positioning type (fixed=fixed position, dynamic=fit screen but keep aspect ratio, fullscreen=scale to fullscreen) "), 0, _UICONFIG( "enum_int:Fixed=0,Fullscreen=1,Dynamic=2" ) ),
        InputPortConfig<int>( "left", "Set left position (fixed mode)" ),
        InputPortConfig<int>( "top", "Set top position (fixed mode)" ),
        InputPortConfig<int>( "width", "Set width (fixed mode)" ),
        InputPortConfig<int>( "height", "Set height (fixed mode)" ),
        InputPortConfig<bool>( "scale", "Set scale" ),
        InputPortConfig<int>( "hAlign", 1, _HELP("Set horizontal align (dynamic mode)"), 0, _UICONFIG("enum_int:Left=0,Middle=1,Right=2")),
        InputPortConfig<int>( "vAlign", 1, _HELP("Set vertical align (dynamic mode)"), 0, _UICONFIG("enum_int:Top=0,Middle=1,Bottom=2")),
        InputPortConfig<bool>( "maximize", "Set if element is maximized (dynamic mode)" ),
        {0}
    };

    static const SOutputPortConfig out_config[] = {
        OutputPortConfig_Void( "OnSet", _HELP("Triggered on set")),
        OutputPortConfig_Void( "OnGet", _HELP("Triggered on get")),
        OutputPortConfig<int>( "type", _HELP("Get positioning type (0=fixed position, 1=scaled to fit screen)")),
        OutputPortConfig<int>( "left", "Get left position" ),
        OutputPortConfig<int>( "top", "Get top position" ),
        OutputPortConfig<int>( "width", "Get width" ),
        OutputPortConfig<int>( "height", "Get height" ),
        OutputPortConfig<bool>( "scale", "Get scale" ),
        OutputPortConfig<int>( "hAlign", "Get horizontal align (0:Left, 1:Middle, 2:Right)"),
        OutputPortConfig<int>( "vAlign", "Get vertical align (0:Bottom, 1:Middle 2:Top"),
        OutputPortConfig<bool>( "maximize", "Get maximize" ),
        {0}
    };

    config.sDescription = "Node to setup constraints for UIElements";
    config.pInputPorts = in_config;
    config.pOutputPorts = out_config;
    config.SetCategory( EFLN_APPROVED );
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void("Enable", _HELP("Enable mouse button info")),
			InputPortConfig_Void("Disable", _HELP("Disable mouse button info")),
			InputPortConfig<bool>("MouseButton", false, _HELP("Output the mouse button info")),
			InputPortConfig<bool>("MouseWheel", false, _HELP("Output the mouse wheel info")),
			{0}
		};

		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig<int>("MousePressed", _HELP("The int represents the mouse button that was pressed")),
			OutputPortConfig<int>("MouseReleased", _HELP("The int represents the mouse button that was released")),
			OutputPortConfig<float>("MouseWheel", _HELP("Positive is wheel up, negative is wheel down")),
			{0}
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Mouse button information");
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = 
		{
			InputPortConfig_Void("Send", _HELP("send dynamic response signal name")),
			InputPortConfig_Void("Cancel", _HELP("cancel dynamic response signal name")),
			InputPortConfig<string>("SignalName", _HELP("dynamic response signal name"), "Name"),
			InputPortConfig<float>("SignalDelay", _HELP("signal delay value"), "Delay"),
			{0}
		};

		static const SOutputPortConfig outputs[] = 
		{
			OutputPortConfig<string> ("Done", _HELP("Will be triggered if the signal was sent/canceled")),
			{0}
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("This node sends a signal to the Dynamic Response System.");
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.SetCategory(EFLN_APPROVED);
	}

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig<float>("Time", -1.0f, _HELP("Blend from the current time in the level to this new specified time. (24 hours value. -1 = no TOD blending)") ),
			InputPortConfig<float>("Duration",  0.f, _HELP("Blend duration in seconds") ),
			InputPortConfig<float>("SunLatitude", -1.f, _HELP("Blend from the current sun latitude in the level to this new specified latitude (value in degrees. -1=no latitude blending)") ),
			InputPortConfig<float>("SunLongitude", -1.f, _HELP("blend from the current sun longitude in the level to this new specified longitude (value in degrees. -1=no longitude blending)") ),
			InputPortConfig<float>("SunPositionUpdateInterval", 1.f,  _HELP("Amount of time in seconds between every update for the repositioning of the sun (0 second means the sun position is constantly updated during the transition) ") ),
			InputPortConfig<float>("ForceUpdateInterval", 1.0f, _HELP("amount of time in seconds between every update of the time of day (0 second means the time of day is constantly updated during the transition, not recommended for low spec) ")),
			InputPortConfig_Void("Start", _HELP("Starts the transition")),
			InputPortConfig_Void("Pause", _HELP("Pause/Unpause the transition")),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig_Void("Done", _HELP("triggers when transition is finished")),
			{0}
		};

		config.sDescription = _HELP("Time of Day and sun position transitions.");
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}

//--------------------------------------------------------------------------------------------
void CFlashUIEndActionNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig_Void( "EndAction", "Trigger to announce that action is finished" ),
		InputPortConfig<bool>( "UseAsState", false, "If this is set to true, the end node will disable this UIAction flowgraph", "DisableAction" ),
		InputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};

	config.pInputPorts = in_config;
	config.pOutputPorts = 0;
	config.sDescription = "End node for UI Action";
	config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void   ("Trigger", _HELP("Trigger this port to actually damage the actor")),
			InputPortConfig<int>   ("damage", 0, _HELP("Amount of damage to exert when [Trigger] is activated"), _HELP("Damage")),
			InputPortConfig<int>   ("damageRelative", 0, _HELP("Amount of damage to exert when [Trigger] is activated. Is relative to the maximun health of the entity. (100 = full max damage). /nwarning: This will only works for entities with a GetMaxHealth() lua function"), _HELP("DamageRelative")),
			InputPortConfig<Vec3>  ("Position", Vec3(ZERO), _HELP("Position of damage")),
			{0}
		};
		config.pInputPorts = inputs;
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.sDescription = _HELP("Damages attached entity by [Damage] when [Trigger] is activated");
		config.SetCategory(EFLN_APPROVED);
	}