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 )
{
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 )
{
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);
}
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 CFlashUIBaseNodeDynPorts::AddParamOutputPorts(const SUIEventDesc::SEvtParams &eventDesc, std::vector<SOutputPortConfig> &ports)
{
for (TUIParams::const_iterator iter = eventDesc.Params.begin(); iter != eventDesc.Params.end(); ++iter)
{
switch (iter->eType)
{
case SUIParameterDesc::eUIPT_Bool:
ports.push_back(OutputPortConfig<bool>( iter->sDisplayName, iter->sDesc ));
break;
case SUIParameterDesc::eUIPT_Int:
ports.push_back(OutputPortConfig<int>( iter->sDisplayName, iter->sDesc ));
break;
case SUIParameterDesc::eUIPT_Float:
ports.push_back(OutputPortConfig<float>( iter->sDisplayName, iter->sDesc ));
break;
case SUIParameterDesc::eUIPT_String:
case SUIParameterDesc::eUIPT_WString:
ports.push_back(OutputPortConfig<string>( iter->sDisplayName, iter->sDesc ));
break;
default:
ports.push_back(OutputPortConfig_AnyType( iter->sDisplayName, iter->sDesc ));
break;
}
}
}
void GetConfiguration(SFlowNodeConfig& config)
{
static const SEntityTagParams defaultTag;
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void("Draw", _HELP("Draw advanced Entity Tag")),
InputPortConfig<string>("Message", _HELP("The message to display")),
InputPortConfig<float>("FadeTime", defaultTag.fadeTime, _HELP("Seconds for fade out")),
InputPortConfig<float>("FontSize", defaultTag.size, _HELP("Input font size")),
InputPortConfig<float>("ViewDistance", defaultTag.viewDistance, _HELP("Distance from camera entity must be within")),
InputPortConfig<string>("StaticID", _HELP("Identifier for displaying static tags")),
InputPortConfig<int>("ColumnNum", defaultTag.column, _HELP("Which column to display on (usually 1)")),
InputPortConfig<Vec3>("Color", Vec3(defaultTag.color.r, defaultTag.color.g, defaultTag.color.b), _HELP("Text color - RGB [0.0 to 1.0]")),
InputPortConfig<float>("Time", defaultTag.visibleTime, _HELP("Seconds to display at full alpha for")),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_AnyType("Done", _HELP("Tag has finished being displayed")),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY | EFLN_AISEQUENCE_SUPPORTED;
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("Draws a text message above an entity");
config.SetCategory(EFLN_DEBUG);
}
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 );
}
void GetConfiguration(SFlowNodeConfig& config)
{
static const SEntityTagParams defaultTag;
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void("Draw", _HELP("Draw Entity Tag")),
InputPortConfig<string>("Message", _HELP("The message to display")),
InputPortConfig<float>("FontSize", defaultTag.size, _HELP("Input font size")),
InputPortConfig<Vec3>("Color", Vec3(defaultTag.color.r, defaultTag.color.g, defaultTag.color.b), _HELP("Text color - RGB [0.0 to 1.0]")),
InputPortConfig<float>("Time", defaultTag.fadeTime, _HELP("Seconds to display for")),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_AnyType("Done", _HELP("Tag has finished being displayed")),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY | EFLN_AISEQUENCE_SUPPORTED;
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("Draws a text message above an entity");
config.SetCategory(EFLN_DEBUG);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "RecentrePose",_HELP("Resets the tracking origin to the headset's current location, and sets the yaw origin to the current headset yaw value") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Done", _HELP("The selected operation has been acknoledge. This output will always get triggered.") ),
OutputPortConfig_AnyType("Triggered", _HELP("The selected operation has been triggered.") ),
OutputPortConfig_AnyType("Failed", _HELP("The selected operation did not work as expected (e.g. the VR operation was not supported).") ),
{0}
};
config.sDescription = _HELP( "Various VR-specific utils" );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<float>( "Read",_HELP("Read the camera angles (Roll,Pitch,Yaw)") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Done", _HELP("The selected operation has been acknoledge. This output will always get triggered.") ),
OutputPortConfig_AnyType("Roll", _HELP("Camera Roll.") ),
OutputPortConfig_AnyType("Pitch", _HELP("Camera Pitch;") ),
OutputPortConfig_AnyType("Yaw", _HELP("Camera Yaw;") ),
{0}
};
config.sDescription = _HELP( "Various VR-specific utils" );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_AnyType("Check", _HELP("Triggers a check of the current input control scheme")),
{0}
};
static const SOutputPortConfig out_config[] =
{
OutputPortConfig_AnyType("Keyboard", _HELP("Outputs the signal from Check input if the current control scheme is keyboard (Focus on keyboard")),
OutputPortConfig_AnyType("KeyboardMouse", _HELP("Outputs the signal from Check input if the current control scheme is keyboardmouse (Focus on mouse with keyboard")),
OutputPortConfig_AnyType("XBoxOneController", _HELP("Outputs the signal from Check input if the current control scheme is XBoxOne controller")),
OutputPortConfig_AnyType("PS4Controller", _HELP("Outputs the signal from Check input if the current control scheme is PS4 controller")),
{0}
};
config.sDescription = _HELP("Provides branching logic for different input control schemes");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
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);
}
void CFlashUIFunctionNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void( "OnCall", "On call" ),
OutputPortConfig_AnyType( "ReturnVal", "Return value of this function" ),
{0}
};
config.pInputPorts = &m_inPorts[0];
config.pOutputPorts = out_config;
config.sDescription = m_funcDesc.sDesc;
config.SetCategory(EFLN_APPROVED);
}
// --------------------------------------------------------------
void CFlashUIFromArrayNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<string>( "Array", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
InputPortConfig_Void( 0 ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<int>( "Count", "Number of elements" ),
OutputPortConfig_AnyType( "Val1", "First value" ),
OutputPortConfig_AnyType( "Val2", "Second value" ),
OutputPortConfig_AnyType( "Val3", "Third value" ),
OutputPortConfig_AnyType( "Val4", "Fourth value" ),
OutputPortConfig<string>( "LeftOver", "If Array has more than four elements, this port returns the \"loeftover\" array" ),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = "Get Values from UI Array";
config.SetCategory(EFLN_APPROVED);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void("Set", _HELP("Triggering this will apply your sound name and duration to the radio chatter system. (Note that this is automatically done if you trigger Enable.)")),
InputPortConfig_Void("Enable", _HELP("Enable Radio Chatter and apply the sound name and duration.")),
InputPortConfig_Void("Disable", _HELP("Disable Radio Chatter.")),
InputPortConfig<string>("sound_Sound", _HELP("The chatter sound to be used. (Leave empty for default.)")),
InputPortConfig<float>("SilenceDurationMin", -1.0f, _HELP("The silence duration used between chatter will be randomly picked within the interval of the specific minimum and the maximum duration. (Set either one of them to -1.0 to use default properties in the system.)" )),
InputPortConfig<float>("SilenceDurationMax", -1.0f, _HELP("The silence duration used between chatter will be randomly picked within the interval of the specific minimum and the maximum duration. (Set either one of them to -1.0 to use default properties in the system.)" )),
{0}
};
static const SOutputPortConfig out_ports[] = {
OutputPortConfig_AnyType("Set", _HELP("The properties have been applied.")),
OutputPortConfig_AnyType("Enabled", _HELP("Radio Chatter was enabled and the properties were applied.")),
OutputPortConfig_AnyType("Disabled", _HELP("Radio Chatter was disabled.")),
{0}
};
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("Radio Chatter refers to the noises emitted from soldiers walkie-talkies. A sound will be emitted from a soldier near the camera. The interval is randomized between the minimum/maximum silence time.");
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);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void("Load"),
InputPortConfig_Void("Save"),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Done", _HELP("Outputs when request was done, doesnt inform whether attributes are loaded or saved successfully")),
{0}
};
config.sDescription = _HELP("This Loads or Saves the online attributes, use the ProfileAttributes to set values for them. Load needs to be called before you are able to edit them");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
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);
}
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);
}
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 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);
}
//--------------------------------------------------------------------------------------------
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);
}
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);
}
// --------------------------------------------------------------
void CFlashUIFromArrayExNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "Get", "Get the value at \"Index\""),
InputPortConfig<string>( "Array", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
InputPortConfig<int>( "Index", "Index" ),
InputPortConfig_Void( 0 ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType( "Value", "Value of element at \"Index\"" ),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = "Get specific Value from UI Array";
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] = {
InputPortConfig<int>("Id", 0, _HELP("Id for the container")),
InputPortConfig_Void("Create",_HELP("Create a container")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<int>("Error", _HELP("the number specifies the error - 1: Container already exists")),
OutputPortConfig_AnyType("Success", _HELP("Operation successfully completed")),
OutputPortConfig<int>("Id", _HELP("Id of the container if successfully created")),
{0}
};
config.sDescription = _HELP("This node is used to create containers");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] = {
InputPortConfig<int>("Id", 0, _HELP("Id for the container")),
InputPortConfig_Void("Start",_HELP("Start iterating")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<int>("Error", _HELP("the number specifies the error - 1: containerId is invalid")),
OutputPortConfig_Void("Done", _HELP("Operation successfully completed")),
OutputPortConfig_AnyType("Out", _HELP("Value from the container")),
{0}
};
config.sDescription = _HELP("This node is used to iterator over containers");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig 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 in_config[] = {
InputPortConfig_AnyType("Input1"),
InputPortConfig_AnyType("Input2"),
InputPortConfig_AnyType("Input3"),
InputPortConfig_AnyType("Input4"),
InputPortConfig_AnyType("Input5"),
InputPortConfig_AnyType("Input6"),
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].");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
