// --------------------------------------------------------------
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);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType("in1", _HELP("Input 1")),
InputPortConfig_AnyType("in2", _HELP("Input 2")),
InputPortConfig_AnyType("in3", _HELP("Input 3")),
InputPortConfig_AnyType("in4", _HELP("Input 4")),
InputPortConfig_AnyType("in5", _HELP("Input 5")),
InputPortConfig_AnyType("in6", _HELP("Input 6")),
InputPortConfig_AnyType("in7", _HELP("Input 7")),
InputPortConfig_AnyType("in8", _HELP("Input 8")),
InputPortConfig_AnyType("in9", _HELP("Input 9")),
InputPortConfig_AnyType("in10", _HELP("Input 10")),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("out", _HELP("Output")),
{0}
};
config.sDescription = _HELP("Port joiner - triggers it's output when any input is triggered");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<string>("filename"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value0"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value1"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value2"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value3"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value4"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value5"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value6"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value7"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value8"),
InputPortConfig<string>("name"),
InputPortConfig_AnyType("value9"),
{0}
};
static const SOutputPortConfig out_config[] = {
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_ADVANCED);
}
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[] = {
InputPortConfig_AnyType("Enable", _HELP("Enables Kinect Speech Recognition (Xbox One)")),
InputPortConfig_AnyType("Disable", _HELP("Disables Kinect Speech Recognition (Xbox One)")),
{0}
};
config.pInputPorts = inputs;
config.sDescription = _HELP("Enables/Disables Kinect Speech Recognition (Xbox One)");
config.SetCategory(EFLN_APPROVED);
}
// ---------------------------------------------------------------
// ---------------------------------------------------------------
// ---------------------------------------------------------------
void CFlashUIBaseNodeDynPorts::AddParamInputPorts(const SUIEventDesc::SEvtParams &eventDesc, std::vector<SInputPortConfig> &ports)
{
for (TUIParams::const_iterator iter = eventDesc.Params.begin(); iter != eventDesc.Params.end(); ++iter)
{
switch (iter->eType)
{
case SUIParameterDesc::eUIPT_Bool:
ports.push_back(InputPortConfig<bool>( iter->sDisplayName, iter->sDesc ));
break;
case SUIParameterDesc::eUIPT_Int:
ports.push_back(InputPortConfig<int>( iter->sDisplayName, iter->sDesc ));
break;
case SUIParameterDesc::eUIPT_Float:
ports.push_back(InputPortConfig<float>( iter->sDisplayName, iter->sDesc ));
break;
case SUIParameterDesc::eUIPT_Vec3:
ports.push_back(InputPortConfig<Vec3>( iter->sDisplayName, iter->sDesc ));
break;
case SUIParameterDesc::eUIPT_String:
ports.push_back(InputPortConfig<string>( iter->sDisplayName, iter->sDesc ));
break;
default:
ports.push_back(InputPortConfig_AnyType( iter->sDisplayName, iter->sDesc ));
break;
}
}
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType("In", _HELP("Input")),
InputPortConfig<int>("outMin", _HELP("Min number of outputs to activate.")),
InputPortConfig<int>("outMax", _HELP("Max number of outputs to activate.")),
{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")),
{0}
};
config.sDescription = _HELP("Passes the activated input value to a random amount [outMin <= random <= outMax] outputs.");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] =
{
InputPortConfig_Void( "Activate", _HELP( "Activate View" ) ),
InputPortConfig<string>( "Url", "", _HELP( "Initial URL" ) ),
InputPortConfig<int>( "Width", 0, _HELP( "Width" ) ),
InputPortConfig<int>( "Height", 0, _HELP( "Height" ) ),
InputPortConfig<bool>( "Transparent", false, _HELP( "Is Transparent" ) ),
InputPortConfig<bool>( "Clickable", true, _HELP( "Is Clickable" ) ),
InputPortConfig<string>( "Mesh", "", _HELP( "Collision Mesh" ) ),
InputPortConfig<bool>( "SharedMemory", true, _HELP( "Uses Shared Memory" ) ),
InputPortConfig_AnyType( NULL ),
};
static const SOutputPortConfig outputs[] =
{
OutputPortConfig<int>( "ViewID", _HELP( "ID for Further Use" ), "nViewID" ),
OutputPortConfig_AnyType( NULL ),
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP( PLUGIN_CONSOLE_PREFIX "CoherentUI on entity" );
config.nFlags |= EFLN_TARGET_ENTITY;
config.SetCategory( EFLN_APPROVED );
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
COMPILE_TIME_ASSERT( PORT_NONE + 1 == 0 ); // or else the automatic boundary checks when incrememting the port number would not work
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType("In", _HELP("Input")),
InputPortConfig<bool> ( "Closed", false, _HELP("If true blocks all signals.")),
InputPortConfig_Void ( "Open", _HELP("Sets [Closed] to false.")),
InputPortConfig_Void ( "Close", _HELP("Sets [Closed] to true.")),
InputPortConfig_Void ("Reset", _HELP("Forces next output to be Port1 again")),
InputPortConfig<bool> ( "Reverse", false, _HELP("If true, the order of output activation is reversed.")),
{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")),
{0}
};
config.sDescription = _HELP("On each [In] trigger, triggers one of the connected outputs in sequential order.");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
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);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
// Define input ports here, in same order as EInputPorts
static const SInputPortConfig inputs[] =
{
InputPortConfig<bool>("Enabled", false, _HELP("Is sending enabled"), 0, 0),
InputPortConfig_AnyType("Send", _HELP("Trigger Send of message")),
InputPortConfig<string>("Address", "225.1.1.2", _HELP("Multicast Address to send to (between 225.0.0.1 and 239.255.255.255)"), 0, 0),
InputPortConfig<int>("Port", 1234, _HELP("Port number"), 0,0),
InputPortConfig<string>("Message", "test", _HELP("Message to Send"), 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<string>("Error", _HELP("Any error messages")),
{0}
};
// Fill in configuration
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Opens a UDP sender");
//config.SetCategory(EFLN_ADVANCED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_AnyType("Enable", _HELP("Enables the node")),
InputPortConfig_AnyType("Disable", _HELP("Disables the node")),
InputPortConfig<string>("CommandID", _HELP("Voice command ID to listen for (Xbox One) - This is the TAG filed of the item in the GRXML file")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void("Active", _HELP("The selected voice command has been triggered (Xbox One)")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Listener for Kinect Voice Commands (Xbox One)");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_AnyType("IsEnabled", _HELP("Is Kinect Speech Recognition Enabled?")),
InputPortConfig_AnyType("IsGrammarInitialised", _HELP("Are Kinect Grammar(s) properly loaded and initialised?")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void("True", _HELP("True")),
OutputPortConfig_Void("False", _HELP("False")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Queries the availability of Kinect Speech Recognition and its grammars (Xbox One)");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_AnyType("StartListening", _HELP("Starts listening to control scheme changes. Always triggers once on start.")),
InputPortConfig_AnyType("StopListening", _HELP("Starts listening to control scheme changes.")),
{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);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType( "start",_HELP("Triggers the start of the counter. If it is counting already, it resets it. Also, wathever was input here, will be output as 'finished' when the counting is done") ),
InputPortConfig_AnyType( "stop",_HELP("Stops counting") ),
InputPortConfig_AnyType( "continue",_HELP("Continues counting") ),
InputPortConfig<float>( "period", 1.f, _HELP("Tick period in seconds") ),
InputPortConfig<int>( "limit",_HELP("How many ticks the counter will do before finish") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("finished", _HELP("triggered when the counting is done. The value will be the same than the 'start' input")),
OutputPortConfig<int>("count", _HELP("outputs the tick counter value")),
{0}
};
config.sDescription = _HELP( "counts a number of ticks specified by 'limit', and then outputs 'finished' with the value the input 'start' had when it was triggered" );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_AnyType("Enable", _HELP("Enables a particular grammar (Xbox One)")),
InputPortConfig_AnyType("Disable", _HELP("Disables a particular grammar (Xbox One)")),
InputPortConfig<string>("GrammarName", _HELP("Name of the grammar to be enabled/disabled (Xbox One)")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void("Enabled", _HELP("The selected grammar has been Enabled (Xbox One)")),
OutputPortConfig_Void("Disabled", _HELP("The selected grammar has been Disabled (Xbox One)")),
OutputPortConfig_Void("NotLoaded", _HELP("The selected grammar is not loaded (Xbox One)")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Enables/Disables the selected Grammar for Kinect Speech Recognition (Xbox One)");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType("Start", _HELP("Trigger to start gathering the frame rate data, it also resets the previous values") ),
InputPortConfig_AnyType("Stop", _HELP("Trigger to stop gathering the frame rate data") ),
InputPortConfig_AnyType("Reset", _HELP("Trigger to reset the frame rate data") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<float>("FrameTime", _HELP("Current frame time")),
OutputPortConfig<float>("FrameRate", _HELP("Current frame rate")),
OutputPortConfig<int>("FrameId", _HELP("Current frame id")),
OutputPortConfig<float>("MinFrameRate", _HELP("Minimum frame rate")),
OutputPortConfig<float>("MaxFrameRate", _HELP("Maximum frame rate")),
OutputPortConfig<float>("AverageFrameRate", _HELP("Average frame rate")),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = _HELP("When activated, this node outputs the current frame rate data and the lowest, highest and the average frame rate.");
config.SetCategory(EFLN_DEBUG);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType("in", "Any value to be logged"),
{0}
};
static const SOutputPortConfig out_config[] = {
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_ADVANCED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_AnyType("DisplayDialog",_HELP("Displays a dialog")),
InputPortConfig_AnyType("CancelDialog",_HELP("Cancels the current dialog")),
InputPortConfig<int>( "Type", 0, _HELP("Dialog Type"), 0, _UICONFIG( "enum_int:WaitDialog=0,WarningDialog=1,ErrorDialog=2,AcceptDeclineDialog=3,ConfirmDialog=4,OkayDialog=5,InputDialog=5" ) ),
InputPortConfig<string>("Title", _HELP("Dialog title")),
InputPortConfig<string>("Message", _HELP("Dialog message")),
InputPortConfig<string>("Param", _HELP("Special param (e.g. for input dialog)")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_AnyType("OnShow", _HELP("Triggers on Show")),
OutputPortConfig<int>("OnResult", _HELP("Returns once the dialog returns: 0=Yes/Ok/Confirm, 1=No/Cancel/Decline, 2=Canceled by system")),
OutputPortConfig<string>("Param", _HELP("Special param (e.g. for input dialog)")),
{0}
};
config.sDescription = _HELP("This node displays a dialog");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] = {
InputPortConfig<int>("Id",_HELP("Which container to manipulate")),
InputPortConfig_AnyType("Add",_HELP("Add the passed item")),
InputPortConfig_AnyType("AddUnique",_HELP("Add the passed item if it didnt exist")),
InputPortConfig_AnyType("Remove",_HELP("Remove all occurrences of the current item")),
InputPortConfig_AnyType("Clear",_HELP("Empty container")),
InputPortConfig_Void("GetCount",_HELP("Get number of elements - result send in success port if containerId was valid")),
InputPortConfig_Void("Delete",_HELP("Delete container")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<int>("Error", _HELP("the number specifies the error - 1: Container ID is invalid")),
OutputPortConfig_AnyType("Success", _HELP("Operation successfully completed")),
{0}
};
config.sDescription = _HELP("This node is used to access and manipulate containers");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<bool> ( "Block", false, _HELP("If true blocks [In] data. Otherwise passes [In] to [Out]")),
InputPortConfig_AnyType("In", _HELP("Input")),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Out", _HELP("Output")),
{0}
};
config.sDescription = _HELP("Blocker - If enabled blocks [In] signals, otherwise passes them to [Out]");
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_AnyType("in",_HELP("Value to be passed after one frame delay"), _HELP("In")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_AnyType("out", _HELP("Out")),
{0}
};
config.sDescription = _HELP("This node will delay passing the signal from [In] to [Out] for one frame");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType("Input1"),
InputPortConfig_Void("Reset", _HELP("Reset (and allow new trigger)") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Out", _HELP("Output")),
{0}
};
config.sDescription = _HELP("Triggers only once and passes from activated Input port to output port [Out]. \nWARNING!! The triggered flag is not serialized on savegame!. \nThis means that even if a previous savegame is loaded after the node has been triggered, the node wont be triggered again");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<string>("Name", _HELP("Name of the attribute as provided in the XMLs")),
InputPortConfig_Void("Get", _HELP("Retrieve the current value, outputted in 'Val'")),
InputPortConfig_AnyType("Set", _HELP("Set a new value for the attribute, input the value in this port")),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Val"),
OutputPortConfig_Void("Error"),
{0}
};
config.sDescription = _HELP("Set or Get profile attributes. \n the available attributes can be found in \\Libs\\Config\\Profiles\\default\\attributes.xml and \\Scripts\\Network\\OnlineAttributes.xml. \n The online attributes require OnlineAttributes to be loaded first - see PlayerProfile:OnlineAttributes");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
//--------------------------------------------------------------------------------------------
void CFlashUIDelayNode::GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] = {
InputPortConfig_AnyType("in",_HELP("Value to be passed after [Delay] time"), _HELP("In")),
InputPortConfig<float>("delay", 1.0f,_HELP("Delay time in seconds"), _HELP("Delay")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_AnyType("out", _HELP("Out")),
{0}
};
config.sDescription = _HELP("This node will delay passing the signal from [In] to [Out] for the specified number of seconds in [Delay]");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] = {
InputPortConfig_AnyType("In",_HELP("Value to be passed after delay time")),
InputPortConfig<float>("MinDelay", 1.0f, _HELP("Minimum random delay time in seconds")),
InputPortConfig<float>("MaxDelay", 2.0f, _HELP("Maximum random delay time in seconds")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_AnyType("Out"),
{0}
};
config.sDescription = _HELP("This node will delay passing the signal from the [In] to [Out] for a random amount of time in the interval [MinDelay,MaxDelay]");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
void CFlowDelayNode::GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] = {
InputPortConfig_AnyType("in",_HELP("Value to be passed after [Delay] time"), _HELP("In")),
InputPortConfig<float>("delay", 1.0f,_HELP("Delay time in seconds"), _HELP("Delay")),
InputPortConfig<bool>("resetOnInput", false,_HELP("When true, the node is reseted with each input (delay counter is reseted to 0, and previous inputs are forgotten)") ),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_AnyType("out", _HELP("Out")),
{0}
};
config.sDescription = _HELP("This node will delay passing the signal from [In] to [Out] for the specified number of seconds in [Delay]");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<string>("Message",_HELP("The message to be sent")),
InputPortConfig<string>("Value",_HELP("An optional value to be sent along with the message")),
InputPortConfig<int>("Target", 0, _HELP("Default (client sends msg to server and vice versa) - All (default + client messages are loopback to itself)"), _HELP("Target"), _UICONFIG("enum_int:Default=0,All=1")), // the values needs to coincide with SNetMsgData::ETarget
InputPortConfig_AnyType("Send", _HELP("Sends the message to the target")),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void("Done", _HELP("Outputs event if the message was successfully sent")),
OutputPortConfig_Void("Error", _HELP("Outputs event if there was a problem with the message")),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_AnyType("In"),
InputPortConfig_Void("Reset", _HELP("Reset (counter starts from 0 again)") ),
InputPortConfig<int>("Limit", 1, _HELP("How many times 'in' triggered values are sent to the output. After this number is reached, the output will not be triggered again (unless a reset is called)"), 0, _UICONFIG("v_min=1,v_max=1000000000") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Out", _HELP("Output the value sent to 'in'")),
{0}
};
config.sDescription = _HELP("The value triggered into 'in' is sent to 'out' a maximum number of times");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_AnyType("Check", _HELP("Triggers a check of the current platform")),
{0}
};
static const SOutputPortConfig out_config[] =
{
OutputPortConfig_AnyType("PC", _HELP("Outputs the signal from Check input if the game runs on PC")),
OutputPortConfig_AnyType("Xbox360", _HELP("Outputs the signal from Check input if the game runs on Xbox360")),
OutputPortConfig_AnyType("PS3", _HELP("Outputs the signal from Check input if the game runs on PS3")),
OutputPortConfig_AnyType("PS4", _HELP("Outputs the signal from Check input if the game runs on PS4")),
OutputPortConfig_AnyType("XboxOne", _HELP("Outputs the signal from Check input if the game runs on XboxOne")),
{0}
};
config.sDescription = _HELP("Provides branching logic for different platforms");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
