void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig_Void( "check", _HELP("Connect event here to check the inventory for the item" ), _HELP("Check") ),
			InputPortConfig<string>( "item", _HELP("The item to add to the inventory" ), _HELP("Item"), _UICONFIG("enum_global_ref:item%s:ItemType")),
			InputPortConfig<string>( "ItemType", "", _HELP("Select from which items to choose"), 0, _UICONFIG("enum_string:All=,Givable=_givable,Selectable=_selectable")),
			{0}
		};

		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig<bool>("out", _HELP("True if the player has the item, false otherwise" ), _HELP("Out") ),
			OutputPortConfig_Void("False", _HELP("Triggered if player does not have the item" )),
			OutputPortConfig_Void("True",  _HELP("Triggered if player has the item" )),
			OutputPortConfig<EntityId>("ItemId", _HELP("Outputs the item's entity id" )),
			{0}
		};

		config.sDescription = _HELP("Check inventory to see if an item is present.");
		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("Play", _HELP("Play the fragment")),
			InputPortConfig<string>("Fragment", _HELP("Fragment name")),
			InputPortConfig<string>("Tags", _HELP("Tags, seperate by + sign")),
			InputPortConfig<int>("Priority", _HELP("Priority, higher number = higher priority")),
			InputPortConfig_Void("Pause", _HELP("Pauses the actionController")),
			InputPortConfig_Void("Resume", _HELP("Resumes this entity's actionController")),
			InputPortConfig_Void("ForceFinishLastQueued", _HELP("Finish the last queued action")),
			{0}
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void     ("Success",  _HELP("Triggers if succeeded to pass the command")),
			OutputPortConfig_Void		("Failed", _HELP("Triggers if anything went wrong")),
			{0}
		};

		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Play a Mannequin Fragment on a given entity with given Tags");
		config.SetCategory(EFLN_ADVANCED);
	}
	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig inp_config[] = 
		{
			InputPortConfig<int>("FilterAI", 0, _HELP("Filter which AIs are used for the alertness value."), _HELP("FilterAI"),_UICONFIG("enum_int:All=0,Enemies=1,Friends=2,Faction=3")),
			InputPortConfig<string>("Faction", "", _HELP("Only used when 'FilterAI' input is set to 'Faction'. )."), 0, "enum_global:Faction"),
			InputPortConfig<bool>("Enabled", true, _HELP("To enable/disable the node.")),
			InputPortConfig_Void("Check", _HELP("instant check.")),
			{0}
		};

		static const SOutputPortConfig out_config[] = 
		{
			OutputPortConfig<int>("alertness", "0 - green\n1 - orange\n2 - red"),
			OutputPortConfig_Void("green"),
			OutputPortConfig_Void("orange"),
			OutputPortConfig_Void("red"),
			{0}
		};

		config.sDescription = _HELP( "The highest level of alertness of the specified AIs" );
		config.pInputPorts = inp_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}
Beispiel #4
0
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);
}
Beispiel #5
0
	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig<int> ("FadeGroup", 0, _HELP("Fade Group [0-3]"), 0, _UICONFIG("enum_int:0=0,1=1,2=2,3=3")),
			InputPortConfig_Void("FadeIn", _HELP("Fade back from the specified color back to normal screen")),
			InputPortConfig_Void("FadeOut", _HELP("Fade the screen to the specified color")),
			InputPortConfig<bool> ("UseCurColor", true, _HELP("If checked, use the current color as Source color. Otherwise use [FadeColor] as Source color and Target color.")),
			InputPortConfig<float>("FadeInTime", 2.0f, _HELP("Duration of fade in")),
			InputPortConfig<float>("FadeOutTime", 2.0f, _HELP("Duration of fade out")),
			InputPortConfig<Vec3> ("color_FadeColor", _HELP("Target Color to fade to")),
			InputPortConfig<string> ("tex_TextureName", _HELP("Texture Name")),
			InputPortConfig<bool> ("UpdateAlways", false, _HELP("If checked, the Fader will be updated always, otherwise only if game is not paused.")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void("FadedIn", _HELP("FadedIn")),
			OutputPortConfig_Void("FadedOut", _HELP("FadedOut")),
			OutputPortConfig<Vec3> ("CurColor", _HELP("Current Faded Color")),
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Controls Screen Fading.");
		config.SetCategory(EFLN_ADVANCED);
	}
Beispiel #6
0
void CD6PlayerCreditRangeNode::GetConfiguration(SFlowNodeConfig& config)
{
    // Input ports
    static const SInputPortConfig inputs[] =
    {
        InputPortConfig_Void("Trigger", _HELP("Run the test")),
        InputPortConfig<unsigned int>("MinAmount", 0.0f, _HELP("Minimum amount to check for"), _HELP("Minimum Amount")),
        InputPortConfig<unsigned int>("MaxAmount", 0.0f, _HELP("Maximum amount to check for"), _HELP("Maximum Amount")),
        {0},
    };

    // Output ports
    static const SOutputPortConfig outputs[] =
    {
        OutputPortConfig_Void("Passed", _HELP("Triggered if test passes (in range)")),
        OutputPortConfig_Void("Failed", _HELP("Triggered if test fails (not in range)")),
        {0},
    };

    // Set up config
    config.nFlags |= EFLN_TARGET_ENTITY;
    config.pInputPorts = inputs;
    config.pOutputPorts = outputs;
    config.sDescription = _HELP("Determines if player's credits are in given range");
    config.SetCategory(EFLN_APPROVED);
}
Beispiel #7
0
	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);
	}
	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		// Define input ports here, in same order as EInputPorts
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Enable", _HELP("Enable receiving signals")),
			InputPortConfig_Void("Disable", _HELP("Disable receiving signals")),
			InputPortConfig<int>("Port", 1234, _HELP("Port number"), 0,0),
			InputPortConfig<string>("Multicast", "225.1.1.2", _HELP("UDP Multicast address (between 225.0.0.1 and 239.255.255.255)"), 0,0),
			{0}
		};

		// Define output ports here, in same oreder as EOutputPorts
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig<bool>("Success", _HELP("UDP socket successfully opened for listening")), 
			OutputPortConfig<bool>("Fail", _HELP("UDP socket failed to open")), 
			OutputPortConfig<bool>("Received", _HELP("New data")), 
			OutputPortConfig_Void("Value", _HELP("Value")),
			OutputPortConfig_Void("Error", _HELP("Error generated by UDP Listener")),
			{0}
		};

		// Fill in configuration
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Opens a Multicast UDP listener");
		//config.SetCategory(EFLN_ADVANCED);
	}
void CFlowNode_SimulateInput::GetConfiguration(SFlowNodeConfig &config)
{
	static const SInputPortConfig in_ports[] =
	{
		InputPortConfig<string>("ActionInput", _HELP("Action input to trigger"), _HELP("Action"), _UICONFIG("enum_global:input_actions")),
		InputPortConfig_Void("Press", _HELP("Simulate press")),
		InputPortConfig_Void("Hold", _HELP("Simulate hold event")),
		InputPortConfig_Void("Release", _HELP("Simulate relase")),
		InputPortConfig<float>("Value", 0.0f, _HELP("Value between 0 and 1")),
		{0}
	};

	static const SOutputPortConfig out_ports[] =
	{
		OutputPortConfig_Void("Pressed", _HELP("Pressed")),
		OutputPortConfig_Void("Held", _HELP("Held")),
		OutputPortConfig_Void("Released", _HELP("Released")),
		{0}
	};

	config.sDescription = _HELP("Simulate player actions input");
	config.pInputPorts = in_ports;
	config.pOutputPorts = out_ports;
	config.SetCategory(EFLN_DEBUG);
}
Beispiel #10
0
	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		// declare input ports
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig<bool>("MissionOnly", "Only trigger on events involving mission tracked entities"),
			InputPortConfig<string>("Class", "AllClasses", "Class you want to filter on. For custom classes, use CustomClasses input", 0,  _UICONFIG("enum_global:entity_classes") ),
			InputPortConfig<string>("CustomClasses", "Optional: Add classes you want to filter the entities on (comma separated)"),
			{0}
		};

		// declare output ports
		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig_Void("EntityAdded", "Fires when a entity is added to the radar from the Mission"),
			OutputPortConfig_Void("EntityRemoved", "Fires when a entity is removed from the radar by a Mission"),
			OutputPortConfig<EntityId>("Entity", "The entity that needs adding"),
			{0}
		};

		// we set pointers in "config" here to specify which input and output ports the node contains
		config.sDescription = _HELP("Fires when entities are added or removed to the radar from a mission");
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.SetCategory(EFLN_APPROVED);
	}
Beispiel #11
0
void CFlashUIActionNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig<string>( "uiActions_UIAction", "Name of UI action", _HELP("UIAction") ),
		InputPortConfig<bool>( "Strict", false, "If true this node will log an error if the UIAction does not exist, otherwise it can be used in a more loose way." ),
		InputPortConfig_Void( "Start", "Start UI action" ),
		InputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnStart", "Triggered if this node starts the action" ),
		OutputPortConfig_Void( "OnEnd", "Triggered if action is stopped and was started by this node" ),
		OutputPortConfig_Void( "OnStartAll", "Always triggered if the action started" ),
		OutputPortConfig_Void( "OnEndAll", "Always triggered if action is stopped" ),
		OutputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};


	config.pInputPorts = in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Controls an UI Action";
	config.SetCategory(EFLN_APPROVED);
}
Beispiel #12
0
	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		// Define input ports here, in same order as EInputPorts
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Enable", _HELP("Enable receiving signals")),
			InputPortConfig_Void("Disable", _HELP("Disable receiving signals")),
			InputPortConfig<int>("Port", 1234, _HELP("Port number"), 0,0),
			{0},
		};

		// Define output ports here, in same oreder as EOutputPorts
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig<bool>("Success", _HELP("UDP socket successfully opened for listening")), 
			OutputPortConfig<bool>("Fail", _HELP("UDP socket failed to open")), 
			OutputPortConfig<bool>("Received", _HELP("New data")), 
			OutputPortConfig_Void("CVAR", _HELP("Value")),
			OutputPortConfig_Void("Value", _HELP("Value")),
			{0},
		};

		// Fill in configuration
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Opens a UDP listener");
		//config.SetCategory(EFLN_ADVANCED);
	}
	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void    ("Play", _HELP("Display USMPlayer and start playback")),
			InputPortConfig_Void    ("Stop", _HELP("Stop playback and hide USMPlayer")),
			InputPortConfig_Void    ("Pause", _HELP("Pause playback")),
			InputPortConfig_Void    ("Resume", _HELP("Resume playback")),
			InputPortConfig<int>    ("InstanceID", -1, _HELP("Instance ID of USMPlayer (e.g. to use USMPlayer on dynamic textures)")),
			InputPortConfig<string> ("VideoFile", _HELP("Name of usm file, file should be placed in Libs/UI/ or subfolder")),
			InputPortConfig<bool>   ("Transparent", false, _HELP("If player background is transparent or not")),
			InputPortConfig<bool>   ("Loop", false, _HELP("If true, video playback loops")),
			InputPortConfig<bool>   ("Skipable", true, _HELP("If true, player can skip video by pressing on of the skip keys (see ActionMap)")),
			InputPortConfig<int>    ("AudioChannel", 0, _HELP("Audio channel")),
			InputPortConfig<int>    ("SubtitleChannel", 0, _HELP("Subtitle channel")),
			InputPortConfig_Null()
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("OnPlay",	_HELP("Triggered once the video started")),
			OutputPortConfig<bool> ("OnStop",	_HELP("Triggered once the video stopped. True if the video was finished, flase if skiped")),
			OutputPortConfig_Void  ("OnPause",	_HELP("Triggered once the video is paused")),
			OutputPortConfig_Void  ("OnResume",	_HELP("Triggered once the video resumes")),
			OutputPortConfig_Void  ("OnLooped",	_HELP("Triggered once the video looped and start again")),
			OutputPortConfig_Void  ("OnVideoNotFound",	_HELP("Triggered on Video was not found")),
			OutputPortConfig_Null()
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP( "Video player node that is using USMPlayer UIElement" );
		config.SetCategory( EFLN_ADVANCED );
	}
	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = 
		{
			InputPortConfig<Vec3>( "Destination",_HELP("Destination") ),
			InputPortConfig<bool>( "DynamicUpdate", true, _HELP("If dynamic update of Destination [follow-during-movement] is allowed or not"), _HELP("DynamicUpdate") ),
			InputPortConfig<int>( "ValueType", 0, _HELP("Defines if the 'Value' input will be interpreted as speed or as time (duration)."), _HELP("ValueType"), _UICONFIG("enum_int:speed=0,time=1") ),
			InputPortConfig<float>( "Speed", 0.f, _HELP("Speed (m/sec) or time (duration in secs), depending on 'ValueType' input."), _HELP("Value")),
			InputPortConfig<float>( "EaseDistance", 0.f, _HELP("Distance from destination at which the moving entity starts slowing down (0=no slowing down)"), _HELP("EaseInDistance") ),
			InputPortConfig<float>( "EaseOutDistance", 0.f, _HELP("Distance from destination at which the moving entity starts slowing down (0=no slowing down)") ),
			InputPortConfig<int> ( "CoordSys", 0, _HELP("Destination in world, local or parent space"), _HELP("CoordSys"), _UICONFIG("enum_int:Parent=0,World=1,Local=2") ),
			InputPortConfig_Void( "Start", _HELP("Trigger this port to start the movement") ),
			InputPortConfig_Void( "Stop",  _HELP("Trigger this port to stop the movement") ),
			{0}
		};
		static const SOutputPortConfig out_config[] = 
		{
			OutputPortConfig<Vec3>("Current",_HELP("Current position")),
			OutputPortConfig_Void("Start", _HELP("Triggered when start input is triggered")),
			OutputPortConfig_Void("Stop", _HELP("Triggered when stop input is triggered")),
			OutputPortConfig_Void("Finish", _HELP("Triggered when destination is reached")),
			OutputPortConfig_Void("DoneTrigger", _HELP("Triggered when destination is reached or stop input is triggered"), 	_HELP("Done")),
			{0}
		};
		config.sDescription = _HELP( "Move an entity to a destination position at a defined speed or in a defined interval of time" );
		config.nFlags |= EFLN_TARGET_ENTITY|EFLN_AISEQUENCE_SUPPORTED;
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}
    virtual void GetConfiguration( SFlowNodeConfig& config )
    {
        static const SInputPortConfig inPorts[] =
        {
            InputPortConfig_Void( "Start" ),
            InputPortConfig_Void( "Stop" ),
            InputPortConfig< string >( "PathName" ),
            InputPortConfig< bool >( "LoopPath", false ),
            InputPortConfig< float >( "Speed", 30 ),
            { 0 }
        };

        static const SOutputPortConfig outPorts[] =
        {
            OutputPortConfig_Void( "ArrivedAtEnd" ),
            OutputPortConfig_Void( "ArrivedNearToEnd" ),
            OutputPortConfig_Void( "Stopped" ),
            { 0 }
        };

        config.pInputPorts = inPorts;
        config.pOutputPorts = outPorts;
        config.nFlags |= EFLN_TARGET_ENTITY;
        config.sDescription = _HELP( "Set the path the AI should follow. When not in combat mode it will follow as accurately as possible from start to end. When in combat mode it represents the path along where the AI is allowed to position itself/patrol." );
        config.SetCategory( EFLN_APPROVED );
    }
//------------------------------------------------------------------------------------------------------
void CFlashUIDisplayConfigNode::GetConfiguration( SFlowNodeConfig &config )
{
    static const SInputPortConfig in_config[] = {
        CreateElementsPort(),
        CreateInstanceIdPort(),
        InputPortConfig_Void( "get",	"Get configuration" ),
        InputPortConfig_Void( "set",	"set configuration" ),

        InputPortConfig<bool>( "cursor", "Enables mouse cursor" ),
        InputPortConfig<bool>( "mouseEvents", "Enables mouse events" ),
        InputPortConfig<bool>( "keyEvents", "Enables mouse events" ),
        InputPortConfig<bool>( "consoleMouse", "Enables use controller stick as mouse on console (only if \"mouseEvents\" is enabled)" ),
        InputPortConfig<bool>( "consoleCursor", "Enables cursor on console (only if \"cursor\" is enabled)" ),
        InputPortConfig<bool>( "controllerInput", "Enables controller input" ),
        InputPortConfig<bool>( "eventsExclusive", "If set to true no other elements will receive events if this element receives them first" ),
        InputPortConfig<bool>( "fixedProjDepth", "If set to true this element will use pseudo 3D mode. The _z value of each movieclip will only affect its size to give the feeling of \"correct\" depth" ),

        InputPortConfig<bool>( "forceNoUnload", "If set to true this element will not be unloaded on level unload (flag will be applied to all instances!)" ),

        InputPortConfig<float>( "alpha", "Alpha" ),
        InputPortConfig<int>( "layer", "layer of the element" ),
        {0}
    };

    static const SOutputPortConfig out_config[] = {
        OutputPortConfig_Void( "OnSet", _HELP("Triggered on set")),
        OutputPortConfig_Void( "OnGet", _HELP("Triggered on get")),
        OutputPortConfig<bool>( "isVisible", "Current menu state" ),

        OutputPortConfig<bool>( "hasCursor", "Current cursor state" ),
        OutputPortConfig<bool>( "hasMouseEvents", "Current mouse event state" ),
        OutputPortConfig<bool>( "hasKeyEvents", "Current key event state" ),
        OutputPortConfig<bool>( "isConsoleMouse", "Current console mouse state" ),
        OutputPortConfig<bool>( "isConsoleCursor", "Current console cursor state" ),
        OutputPortConfig<bool>( "isControllerInput", "Current controller input state" ),
        OutputPortConfig<bool>( "isEventsExclusive", "Current event exclusive state" ),
        OutputPortConfig<bool>( "isFixedProjDepth", "Current fixedProjDepth state" ),

        OutputPortConfig<bool>( "isForceNoUnload", "Current forceNoUnload state" ),

        OutputPortConfig<float>( "alpha", "Current alpha value" ),
        OutputPortConfig<int>( "layer", "layer of the element" ),
        {0}
    };

    config.sDescription = "Node to setup flags for UIElements";
    config.pInputPorts = in_config;
    config.pOutputPorts = out_config;
    config.SetCategory( EFLN_APPROVED );
}
// --------------------------------------------------------------
void CFlashUIDisplayNode::GetConfiguration( SFlowNodeConfig &config )
{
    static const SInputPortConfig in_config[] = {
        CreateElementsPort(),
        CreateInstanceIdPort(),
        InputPortConfig_Void( "show",        "Display UI element" ),
        InputPortConfig_Void( "hide",        "Hide UI element" ),
        InputPortConfig_Void( "unload",      "Unload UI element" ),
        InputPortConfig_Void( "requestHide", "Send request for hide to flash asset, to allow fade out" ),
        InputPortConfig_Void( "init",        "Inits the flash file" ),
        InputPortConfig_Void( "reload",      "Reloads the flash file" ),
        InputPortConfig_Void( "unloadBootstrapper", "Unloads the bootstrapper for this UI Element. Will unload all Instances of this element" ),
        InputPortConfig_Void( "reloadBootstrapper", "Reloads the bootstrapper for this UI Element. Will reload all Instances of this element" ),
        {0}
    };

    static const SOutputPortConfig out_config[] = {
        OutputPortConfig_Void( "onShow",        "Triggered when display was called" ),
        OutputPortConfig_Void( "onHide",        "Triggered when hide was called" ),
        OutputPortConfig_Void( "onUnload",      "Triggered when unload was called" ),
        OutputPortConfig_Void( "onRequestHide", "Triggered when hide was requested" ),
        OutputPortConfig_Void( "onInit",        "Triggered when init was called" ),
        OutputPortConfig_Void( "onReload",      "Triggered when reload was called" ),
        OutputPortConfig_Void( "onUnloadBootstrapper", "Triggered when unload bootstrapper was called" ),
        OutputPortConfig_Void( "onReloadBootstrapper", "Triggered when reload bootstrapper was called" ),
        {0}
    };

    config.sDescription = "Node to display/hide/reload UIElements";
    config.pInputPorts = in_config;
    config.pOutputPorts = out_config;
    config.SetCategory( EFLN_APPROVED );
}
Beispiel #18
0
void CFlowNode_FeatureTest::GetConfiguration(SFlowNodeConfig &config)
{
	static const SInputPortConfig inputs[] =
	{
		InputPortConfig<string>	("Name",				_HELP("Name of the feature test. Should be short, unique and descriptive. Appended with entity name if test is sequential.")),
		InputPortConfig<string>	("Description",	_HELP("Description of the feature test. What feature is being tested and how it's being tested.")),
		InputPortConfig<bool>	("Ready",				true, _HELP("Boolean to indicate if all dependencies have been met and this test is ready to run.")),
		// TODO: Categories?
		InputPortConfig<float>	("MaxTime",			30.0f, _HELP("How long (in game time) is the test is allow to run before it fails (seconds).")),
		InputPortConfig<bool>	("LabelProfileData", false, _HELP("If true then frame profile capture data will be labeled with the name of this test.")),
		InputPortConfig<string>	("Owners", _HELP("A string containing semi-colon separated names of owners (by domain name) responsible for this test.")),

		InputPortConfig<bool>	("Sequential",	true, _HELP("If true the entities are tested in individually (in sequence). Otherwise entities all are tested together.")),

		InputPortConfig<EntityId> ("Camera",			_HELP("Optional entity used to act as the camera for the test. Does not have to be a real camera.")),

		InputPortConfig<EntityId> ("Entity1",			_HELP("Test Entity 1, allows entities associated with the test to be automatically hidden and shown.")),
		InputPortConfig<EntityId> ("Entity2",			_HELP("Test Entity 2, allows entities associated with the test to be automatically hidden and shown.")),
		InputPortConfig<EntityId> ("Entity3",			_HELP("Test Entity 3, allows entities associated with the test to be automatically hidden and shown.")),
		InputPortConfig<EntityId> ("Entity4",			_HELP("Test Entity 4, allows entities associated with the test to be automatically hidden and shown.")),
		InputPortConfig<EntityId> ("Entity5",			_HELP("Test Entity 5, allows entities associated with the test to be automatically hidden and shown.")),
		InputPortConfig<EntityId> ("Entity6",			_HELP("Test Entity 6, allows entities associated with the test to be automatically hidden and shown.")),

		InputPortConfig_Void("Succeeded",		_HELP("Trigger to indicated the feature test has passed. Cleanup will then be triggered.")),
		InputPortConfig_Void("Failed",			_HELP("Trigger to indicated the feature test has filed.")),
		{0}
	};

	static const SOutputPortConfig outputs[] =
	{
		OutputPortConfig_Void("Start",						_HELP("Trigger to start running the feature test.")),
		OutputPortConfig<EntityId>("SequenceEntity",	_HELP("Outputs the entity in use for this part of the test. Only used if Sequential is true and entities are set.")),
		OutputPortConfig_Void("Cleanup",					_HELP("Trigger to cleanup the feature test once it's done.")),

		OutputPortConfig<bool>	("Entity1Passed",		_HELP("Outputs true when Entity1 has successfully run the test. Only used if Sequential is true and Entity1 is set.")),
		OutputPortConfig<bool>	("Entity2Passed",		_HELP("Outputs true when Entity2 has successfully run the test. Only used if Sequential is true and Entity2 is set.")),
		OutputPortConfig<bool>	("Entity3Passed",		_HELP("Outputs true when Entity3 has successfully run the test. Only used if Sequential is true and Entity3 is set.")),
		OutputPortConfig<bool>	("Entity4Passed",		_HELP("Outputs true when Entity4 has successfully run the test. Only used if Sequential is true and Entity4 is set.")),
		OutputPortConfig<bool>	("Entity5Passed",		_HELP("Outputs true when Entity5 has successfully run the test. Only used if Sequential is true and Entity5 is set.")),
		OutputPortConfig<bool>	("Entity6Passed",		_HELP("Outputs true when Entity6 has successfully run the test. Only used if Sequential is true and Entity6 is set.")),

		OutputPortConfig<bool>	("AllPassed",				_HELP("Outputs true when the test has been successfully run and all sequential entities passed their tests.")),
		{0}
	};

	config.pInputPorts = inputs;
	config.pOutputPorts = outputs;
	config.sDescription = _HELP("Feature Test node that controls automated feature tests");
	config.SetCategory(EFLN_DEBUG);
}
            virtual void GetConfiguration( SFlowNodeConfig& config )
            {
                static const SInputPortConfig inputs[] =
                {
                    InputPortConfig_Void( "Open",                                _HELP( "Open / Start paused (call Resume)" ) ),
                    InputPortConfig_Void( "Close",                               _HELP( "Close / Stop" ) ),

                    InputPortConfig<string>( "file_File",    "",                 _HELP( "videofile (set on Open)" ),                   "sFile",                        _UICONFIG( "" ) ),
                    InputPortConfig<string>( "sound_Sound",  "",                 _HELP( "soundfile/event (set on Open)" ),             "sSound",                       _UICONFIG( "" ) ),
                    InputPortConfig<bool>( "Loop",           true,               _HELP( "loops the video (set on Open)" ),             "bLoop" ),
                    InputPortConfig<bool>( "Skippable",      false,              _HELP( "Can this video be skipped by the user" ),     "bSkippable" ),
                    InputPortConfig<bool>( "BlockGame",      false,              _HELP( "Block Game while this video is playing" ),    "bBlockGame" ),

                    InputPortConfig<float>( "StartAt",       0.0,                _HELP( "start [sec]" ),                               "fStartAt" ),
                    InputPortConfig<float>( "EndAfter",      0.0,                _HELP( "end/loop [sec]" ),                            "fEndAfter" ),
                    InputPortConfig<int>( "CustomWidth",     -1,                 _HELP( "custom render width [px]" ),                  "nCustomWidth" ),
                    InputPortConfig<int>( "CustomHeight",    -1,                 _HELP( "custom render height [px]" ),                 "nCustomHeight" ),
                    InputPortConfig<int>( "TimeSource",      int( VTS_Default ),   _HELP( "timesource to sync to" ),                     "nTimeSource",                  _UICONFIG( "enum_int:Game=1,Sound=2,System=4,SoundOrGame=3,SoundOrSystem=6" ) ),
                    InputPortConfig<int>( "DropMode",        int( VDM_Default ),   _HELP( "dropmode to use for sync" ),                  "nDropMode",                    _UICONFIG( "enum_int:None=0,Drop=1,Seek=2,DropOutput=4,DropOrSeek=3,DropOutputOrSeek=6" ) ),
                    InputPortConfig<float>( "Speed",         1.0,                _HELP( "play speed" ),                                "fSpeed" ),

                    InputPortConfig_Void( "Resume",                              _HELP( "Resume" ) ),
                    InputPortConfig_Void( "Pause",                               _HELP( "Pause" ) ),

                    InputPortConfig_Void( "Seek",                                _HELP( "seeks to position" ) ),
                    InputPortConfig<float>( "PositionI",     0.0,                _HELP( "position for seek [sec]" ),                   "fPosition" ),
                    InputPortConfig_Null(),
                };

                static const SOutputPortConfig outputs[] =
                {
                    OutputPortConfig<int>( "VideoID",                            _HELP( "id for further use" ),                        "nVideoID" ),
                    OutputPortConfig<bool>( "Playing",                           _HELP( "currently playing" ),                         "bPlaying" ),
                    OutputPortConfig<float>( "PositionO",                        _HELP( "position [sec]" ),                            "fPosition" ),
                    OutputPortConfig_Void( "OnStart",                            _HELP( "start/loop begin reached" ) ),
                    OutputPortConfig_Void( "OnEnd",                              _HELP( "End reached" ) ),
                    OutputPortConfig<float>( "Duration",                         _HELP( "duration [sec]" ),                            "fDuration" ),
                    OutputPortConfig<float>( "FPS",                              _HELP( "frames per second" ),                         "fFPS" ),
                    OutputPortConfig<int>( "Width",                              _HELP( "decoder width [px]" ),                        "nWidth" ),
                    OutputPortConfig<int>( "Height",                             _HELP( "decoder height [px]" ),                       "nHeight" ),
                    OutputPortConfig_Null(),
                };

                config.pInputPorts = inputs;
                config.pOutputPorts = outputs;
                config.sDescription = _HELP( PLUGIN_CONSOLE_PREFIX "Videosource WebM" );

                config.SetCategory( EFLN_APPROVED );
            }
void CFlowConvoyNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig<string>( "Path",_HELP("Path to move the train on") ),
		InputPortConfig<int>( "LoopCount",0,_HELP("How many times to loop along the path (-1 for infinite)") ),
		InputPortConfig<float>( "Speed",_HELP("Speed in m/s (not work with negative speed)") ),
		InputPortConfig<float>( "DesiredSpeed",_HELP("Speed in m/s (not work with negative speed)") ),
		InputPortConfig<bool>( "Shift",_HELP("dO SHIFT") ),
		InputPortConfig<float>( "ShiftTime",_HELP("Speed in m/s (not work with negative speed)") ),
		InputPortConfig<float>( "StartDistance",_HELP("Start distance of the last coach end (from the start of the path)") ),
		InputPortConfig<int>( "SplitCoachNumber",_HELP("If acticated, the train splits from this coach") ),
		InputPortConfig<bool>( "XAxisIsForward", false, _HELP("If true, and coaches are not CHRs, will make X axis forward instead of Y") ),
		InputPortConfig_Void( "PlayHornSound",_HELP("If acticated, train horn sound played") ),
		InputPortConfig_Void( "PlayBreakSound",_HELP("If acticated, train break sound played") ),
		InputPortConfig_Void( "Start",_HELP("Trigger to start the convoy") ),
		InputPortConfig_Void( "Stop",_HELP("Trigger to stop the convoy") ),
		{0}
	};
	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void("onPathEnd", _HELP("Triggers when first coach reaches the end of the path")),
		OutputPortConfig<int> ("PlayerCoachIndex", _HELP("gives the coach index Player is standing on, (-1) if not on train for at least 4 seconds")),
		{0}
	};

	config.sDescription = _HELP( "Convoy node will move a special entity on an AIPath with speed" );
	config.pInputPorts = in_config;
	config.pOutputPorts = out_config;
	config.SetCategory(EFLN_APPROVED);
	config.nFlags |= EFLN_TARGET_ENTITY;
}
Beispiel #21
0
	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		// declare input ports
		static const string uiconfig = HUDEVENT_UICONFIG_ENTRY_FIRST(eHUDEvent_LeavingBattleArea)HUDEVENT_UICONFIG_ENTRY_ADDITIONAL(eHUDEvent_ReturningToBattleArea);

		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig<int>("Event", 2, _HELP(""), "Event", uiconfig.c_str()),
			{0}
		};

		// declare output ports
		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig_Void("EventFired", "Fires when the event occurs"),
			OutputPortConfig<float>("DeathTimer", "Outputs current game time plus specified Delay time in ForbiddenArea entity"),
			{0}
		};

		// we set pointers in "config" here to specify which input and output ports the node contains
		config.sDescription = _HELP("Used to catch HUD events about leaving and entering battle area");
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.SetCategory(EFLN_APPROVED);
	}
void CFlowNode_AISequenceAction_ApproachAndEnterVehicle::GetConfiguration(SFlowNodeConfig& config)
{
	static const SInputPortConfig inputPortConfig[] =
	{
		InputPortConfig_Void("Start"),
		InputPortConfig<EntityId>("VehicleId", _HELP("Vehicle to be entered")),
		InputPortConfig<int>("SeatNumber", _HELP("Seat to be entered"), _HELP("Seat"), _UICONFIG("enum_int:None=0,Driver=1,Gunner=2,Seat03=3,Seat04=4,Seat05=5,Seat06=6,Seath07=7,Seat08=8,Seat09=9,Seat10=10,Seat11=11")),
		InputPortConfig<int>("Speed", _HELP("Speed to approach the vehicle with"), NULL, _UICONFIG("enum_int:Walk=0,Run=1,Sprint=2")),
		InputPortConfig<int>("Stance", _HELP("Stance while approaching the vehicle"), NULL, _UICONFIG("enum_int:Relaxed=0,Alert=1,Combat=2")),
		InputPortConfig<bool>("Fast", _HELP("skip approaching and entering animation")),
		{ 0 }
	};

	static const SOutputPortConfig outputPortConfig[] =
	{
		OutputPortConfig_Void("Done"),
		{ 0 }
	};

	config.pInputPorts = inputPortConfig;
	config.pOutputPorts = outputPortConfig;
	config.sDescription = _HELP("Allows the AI agent to move to the specified vehicle and to then enter the specified seat");
	config.nFlags |= EFLN_TARGET_ENTITY | EFLN_AISEQUENCE_ACTION;
	config.SetCategory(EFLN_APPROVED);
}
Beispiel #23
0
// --------------------------------------------------------------
void CFlashUIToArrayNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig_Void( "Set", "Set this array"),
		InputPortConfig<int>( "Count", 4, _HELP("Number of elements for this array"), 0, _UICONFIG( "enum_int:1,2,3,4" )),
		InputPortConfig_AnyType( "Val1", "First value" ),
		InputPortConfig_AnyType( "Val2", "Second value" ),
		InputPortConfig_AnyType( "Val3", "Third value" ),
		InputPortConfig_AnyType( "Val4", "Fourth value" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnSet", "On Set this array" ),
		OutputPortConfig<string>( "Array", UIARGS_DEFAULT_DELIMITER_NAME " separated list" ),
		{0}
	};

	config.pInputPorts  = in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Create an UI Array";
	config.SetCategory(EFLN_APPROVED);

}
Beispiel #24
0
	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig_AnyType("In", _HELP("Input")),
			InputPortConfig_Void("Reset", _HELP("Reset randomness")),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig_AnyType("Out1", _HELP("Output1")),
			OutputPortConfig_AnyType("Out2", _HELP("Output2")),
			OutputPortConfig_AnyType("Out3", _HELP("Output3")),
			OutputPortConfig_AnyType("Out4", _HELP("Output4")),
			OutputPortConfig_AnyType("Out5", _HELP("Output5")),
			OutputPortConfig_AnyType("Out6", _HELP("Output6")),
			OutputPortConfig_AnyType("Out7", _HELP("Output7")),
			OutputPortConfig_AnyType("Out8", _HELP("Output8")),
			OutputPortConfig_AnyType("Out9", _HELP("Output9")),
			OutputPortConfig_AnyType("Out10", _HELP("Output10")),
			OutputPortConfig_Void("Done", _HELP("Triggered after all [connected] outputs have triggered")),
			{0}
		};
		config.sDescription = _HELP("On each [In] trigger, triggers one of the connected outputs in random order.");
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
		config.SetCategory(EFLN_APPROVED);
	}
	void GetConfiguration(SFlowNodeConfig &config)
	{
		ScopedSwitchToGlobalHeap useGlobalHeap;
		static const SInputPortConfig in_config[] =
		{
			InputPortConfig_Void		("Save", _HELP("Trigger to save game")),
			InputPortConfig_Void		("Load", _HELP("Trigger to load game")),
			InputPortConfig<string>	("Name", string("quicksave"), _HELP("Name of SaveGame to save/load. Use $LAST to load last savegame")),
			InputPortConfig<string>	("Desc", string(), _HELP("Description [Currently ignored]"), _HELP("Description")),
			InputPortConfig_Void		("EnableSave", _HELP("Trigger to globally allow quick-saving")),
			InputPortConfig_Void		("DisableSave", _HELP("Trigger to globally disallow quick-saving")),
			InputPortConfig<bool>		("DelaySaveIfPlayerInAir", false, _HELP("if true, the savegame will be delayed until the the player is no longuer in air (jumping, falling, etc). /nUse only in case there is a real danger of problem with the checkpoint (player dying after fall, for example)")),
			{0}
		};

		static const SOutputPortConfig out_config[] =
		{
			OutputPortConfig_Void	("SaveOrLoadDone", _HELP("Triggered after the savegame is created and also after the savegame is loaded./n"
			"When saving, the trigger hapens after the 'snapshot' of the game state is taken. The actual physical writing of the data into the HD or memory card could take longer./n"
			"this output will also be triggered if there was any critical error and the savegame could not be created"
			)),
			{0}
		};

		config.sDescription	= _HELP("SaveGame for Autosave");
		config.pInputPorts	= in_config;
		config.pOutputPorts	= out_config;

		config.SetCategory(EFLN_APPROVED);
	}
Beispiel #26
0
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);
}
	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("Triggered", _HELP("Triggered when the smartobject is used")),
			OutputPortConfig_Void  ("Triggered_Reverse", _HELP("Triggered when the smartobject is used")),
			OutputPortConfig<EntityId> ("UserId", _HELP("Entity that is using the smartobject")),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("SmartObject Node");
		config.SetCategory(EFLN_APPROVED);
	}
Beispiel #28
0
	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig_Void( "FailCurrentScan",_HELP("Trigger to fail current scan") ),
			InputPortConfig_Void( "SucceedCurrentScan",_HELP("Trigger to succeed current scan") ),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig_Void( "Failed", _HELP("Triggered when fail input is triggered") ),
			OutputPortConfig_Void( "Succeeded", _HELP("Triggered when succeed input is triggered") ),
			{0}
		};
		config.sDescription = _HELP( "Can control the tactical scan that is currently in progress" );
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}
            virtual void GetConfiguration( SFlowNodeConfig& config )
            {
                static const SInputPortConfig inputs[] =
                {
                    InputPortConfig_Void( "Open",                                _HELP( "Open / Start paused (call Resume)" ) ),
                    InputPortConfig_Void( "Close",                               _HELP( "Close / Stop" ) ),

                    InputPortConfig<string>( "file_File",    "",                 _HELP( "playlist xml file" ),                 "sFile",                        _UICONFIG( "" ) ),
                    InputPortConfig<bool>( "Loop",           true,               _HELP( "loops the playlist (set on Open)" ),              "bLoop" ),
                    InputPortConfig<bool>( "Skippable",  true,       _HELP( "Can this playlist be skipped by the user" ),      "bSkippable" ),
                    InputPortConfig<bool>( "BlockGame",  false,      _HELP( "Block Game while this playlist is playing" ),     "bBlockGame" ),

                    InputPortConfig<int>( "StartAt",         0.0,                _HELP( "start [scene]" ),                             "nStartAt" ),
                    InputPortConfig<int>( "EndAfter",        0.0,                _HELP( "end/loop [scene]" ),                          "nEndAfter" ),

                    InputPortConfig_Void( "Resume",                              _HELP( "Resume" ) ),
                    InputPortConfig_Void( "Pause",                               _HELP( "Pause" ) ),
                    {0},
                };

                static const SOutputPortConfig outputs[] =
                {
                    OutputPortConfig<int>( "VideoID",                            _HELP( "id for further use" ),                        "nVideoID" ),
                    OutputPortConfig<int>( "VideoID2",                           _HELP( "id2 for further use" ),                       "nVideoID2" ),
                    OutputPortConfig<int>( "VideoID3",                           _HELP( "id3 for further use" ),                       "nVideoID3" ),
                    OutputPortConfig<bool>( "Playing",                           _HELP( "currently playing" ),                         "bPlaying" ),

                    OutputPortConfig_Void( "OnStart",                            _HELP( "Start reached" ) ),
                    OutputPortConfig_Void( "OnEnd",                              _HELP( "End reached" ) ),
                    OutputPortConfig_Void( "OnSceneStart",                       _HELP( "Scene start reached" ) ),
                    OutputPortConfig_Void( "OnSceneEnd",                         _HELP( "Scene end reached" ) ),
                    OutputPortConfig_Void( "OnVideoStart",                       _HELP( "Video1 start reached" ) ),
                    OutputPortConfig_Void( "OnVideoEnd",                         _HELP( "Video1 end reached" ) ),
                    OutputPortConfig_Void( "OnVideoStart2",                      _HELP( "Video2 start reached" ) ),
                    OutputPortConfig_Void( "OnVideoEnd2",                        _HELP( "Video2 end reached" ) ),
                    OutputPortConfig_Void( "OnVideoStart3",                      _HELP( "Video3 start reached" ) ),
                    OutputPortConfig_Void( "OnVideoEnd3",                        _HELP( "Video3 end reached" ) ),
                    {0},
                };

                config.pInputPorts = inputs;
                config.pOutputPorts = outputs;
                config.sDescription = _HELP( PLUGIN_CONSOLE_PREFIX "Videosource Playlist" );

                config.SetCategory( EFLN_APPROVED );
            }
	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig_Void("Set", _HELP("Sets the material on the ocean")),
			InputPortConfig<string>("Material", _HELP("Material of choice to be set"), 0, _UICONFIG("dt=mat")),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig_Void("Success", _HELP("Triggered when successfully finished")),
			OutputPortConfig_Void("Failed", _HELP("Triggered when something went wrong")),
			{0}
		};
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.sDescription = _HELP("Set the ocean material");
		config.SetCategory(EFLN_APPROVED);
	}