virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<bool>( "A",_HELP("out = A op B") ),
InputPortConfig<bool>( "B",_HELP("out = A op B") ),
InputPortConfig<bool>( "Always", _HELP("if true, the outputs will be activated every time an input is. If false, outputs only will be activated when the value does change") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<bool>("out",_HELP("out = A op B")),
OutputPortConfig<bool>("true",_HELP("triggered if out is true")),
OutputPortConfig<bool>("false",_HELP("triggered if out is false")),
{0}
};
config.sDescription = _HELP( "Do logical operation on input ports and outputs result to [out] port. True port is triggered if the result was true, otherwise the false port is triggered." );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] =
{
InputPortConfig<bool>("Enabled", true, _HELP("To enable/disable the node.")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<int>("Awareness", _HELP("0-100")),
OutputPortConfig_Void("green", _HELP("Awareness=0")),
OutputPortConfig_Void("yellow", _HELP("Awareness between 0-50")),
OutputPortConfig_Void("red", _HELP("Awareness >50")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Outputs a value that represents the AI enemy awareness of the player. This value closely matches the HUD alertness indicator. \nOutputs are triggered only when they change.");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig<bool> ("Asian", false, _HELP("If true, use Asian material, otherwise US")),
InputPortConfig_Void ("Cloak", _HELP("Trigger to select Cloak Mode")),
InputPortConfig_Void ("Strength", _HELP("Trigger to select Strength Mode")),
InputPortConfig_Void ("Defense", _HELP("Trigger to select Defense Mode")),
InputPortConfig_Void ("Speed", _HELP("Trigger to select Speed Mode")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void("Done", _HELP("Triggered when Done.")),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Fake Materials on Characters (non Player/AI) NanoSuit for Cinematics");
config.SetCategory(EFLN_WIP);
}
virtual void GetConfiguration(SFlowNodeConfig &config)
{
static const SInputPortConfig inputs[] =
{
InputPortConfig_Void("Get", _HELP("Get minimap info")),
{0}
};
static const SOutputPortConfig outputs[] =
{
OutputPortConfig_Void("OnGet", _HELP("Tirggers of port <Get> is activeated")),
OutputPortConfig<string>("MapFile", _HELP("Name of minimap dds file")),
OutputPortConfig<int> ("Width", _HELP("Minimap width")),
OutputPortConfig<int> ("Height", _HELP("Minimap height")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Info about minimap");
config.SetCategory(EFLN_ADVANCED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<Vec3>( "pos", "Input camera position." ),
InputPortConfig<Vec3>( "dir", "Input camera direction." ),
InputPortConfig<float>( "roll", "Input camera roll." ),
InputPortConfig<bool>( "active", true, "While false, the node wont output any value" ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<Vec3>("pos", "Current camera position."),
OutputPortConfig<Vec3>("dir", "Current camera direction."),
OutputPortConfig<float>("roll", "Current camera roll."),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_OBSOLETE);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void( "Activate", _HELP("Connect event here to remove all items from inventory" )),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig<bool>("Done", _HELP("True when done successfully")),
{0}
};
config.sDescription = _HELP("When activated, removes all items from inventory.");
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void ("Link", _HELP("Link the Player to Target Entity")),
InputPortConfig_Void ("Unlink", _HELP("Unlink the Player (from any Entity)")),
InputPortConfig<EntityId> ("Target", _HELP("Target Entity Id") ),
InputPortConfig<int> ("DrawPlayer", 0, _HELP("Draw the Player (Hide=-1, NoChange=0, Show=1)"), 0, _UICONFIG("enum_int:NoChange=0,Hide=-1,Show=1")),
InputPortConfig<bool> ("KeepTransformationOnUnlink", true, _HELP("Keep Transformation on Unlink")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void ("Linked", _HELP("Trigger if Linked")),
OutputPortConfig_Void ("Unlinked", _HELP("Trigger if Unlinked")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Linking the Player to an Entity (with FreeLook)");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_Void ( "Trigger", _HELP("show debug informations on screen") ),
InputPortConfig<float> ( "Size", 1.5f, _HELP("font size")),
InputPortConfig<string>( "vehicleParts_Parts", _HELP("select vehicle parts"), 0, _UICONFIG("ref_entity=entityId") ),
{0}
};
static const SOutputPortConfig out_config[] =
{
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_DEBUG);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_AnyType("Check", _HELP("Triggers a check of the current input control scheme")),
{0}
};
static const SOutputPortConfig out_config[] =
{
OutputPortConfig_AnyType("Keyboard", _HELP("Outputs the signal from Check input if the current control scheme is keyboard (Focus on keyboard")),
OutputPortConfig_AnyType("KeyboardMouse", _HELP("Outputs the signal from Check input if the current control scheme is keyboardmouse (Focus on mouse with keyboard")),
OutputPortConfig_AnyType("XBoxOneController", _HELP("Outputs the signal from Check input if the current control scheme is XBoxOne controller")),
OutputPortConfig_AnyType("PS4Controller", _HELP("Outputs the signal from Check input if the current control scheme is PS4 controller")),
{0}
};
config.sDescription = _HELP("Provides branching logic for different input control schemes");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void("Enable", _HELP("Enable reporting")),
InputPortConfig_Void("Disable", _HELP("Disable reporting")),
InputPortConfig<int>("Key", 0, _HELP("XBoxOne controller key"), NULL, _UICONFIG(XBoxAnalogEnum)),
InputPortConfig<bool>("NonDevMode", false, _HELP("If set to true, can be used in Non-Devmode as well [Debugging backdoor]")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<float>("ChangedX", _HELP("Called when analog changes in X (trigger info sent out here as well)")),
OutputPortConfig<float>("ChangedY", _HELP("Called when analog changes in Y")),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Get analog input from XBox 360 controller. Note: Expensive! Note2: entity input is used in multiplayer");
config.SetCategory(EFLN_DEBUG);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void("Enable", _HELP("Enable reporting")),
InputPortConfig_Void("Disable", _HELP("Disable reporting")),
InputPortConfig<int>("Key", 0, _HELP("XBoxOne controller key"), NULL, _UICONFIG(XBoxKeyEnum)),
InputPortConfig<bool>("NonDevMode", false, _HELP("If set to true, can be used in Non-Devmode as well [Debugging backdoor]")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void("Pressed", _HELP("Called when key is pressed")),
OutputPortConfig_Void("Released", _HELP("Called when key is released")),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Get input from XBox 360 controller. EntityInput is used in multiplayer");
config.SetCategory(EFLN_DEBUG);
}
void CFlashUIInventoryNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "Call", "Calls the function" ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void( "OnCall", "Triggered if this node starts the action" ),
OutputPortConfig<string>( "Args", "Comma separated argument string" ),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = "Outputs the players inventory as a string for UI processing";
config.SetCategory(EFLN_APPROVED);
}
// --------------------------------------------------------------
void CFlashUIFromArrayExNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "Get", "Get the value at \"Index\""),
InputPortConfig<string>( "Array", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
InputPortConfig<int>( "Index", "Index" ),
InputPortConfig_Void( 0 ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType( "Value", "Value of element at \"Index\"" ),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = "Get specific Value from UI Array";
config.SetCategory(EFLN_APPROVED);
}
//------------------------------------------------------------------------------------------------------
void CFlashUIPlatformNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "get", "Get current platform" ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void( "IsPc", _HELP("Triggered on PC")),
OutputPortConfig_Void( "IsXBoxOne", _HELP("Triggered on XBox One")),
OutputPortConfig_Void( "IsPS4", _HELP("Triggered on PS4")),
OutputPortConfig_Void( "IsConsole", _HELP("Triggered on Consoles") ),
{0}
};
config.sDescription = "Node to get current platform, works also with selected platform of UIEmulator";
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory( EFLN_APPROVED );
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void( "Check", _HELP("Trigger this port to check if Actor's current weapon is zoomed" )),
InputPortConfig<string>( "Weapon", _HELP("Name of Weapon to check. Empty=All."), 0, _UICONFIG("enum_global:weapon")),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_Void( "False", _HELP("Triggered if weapon is not zoomed.")),
OutputPortConfig_Void( "True", _HELP("Triggered if weapon is zoomed.")),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("Checks if target actor's current weapon is zoomed.");
config.SetCategory(EFLN_WIP);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inputs[] = {
InputPortConfig<int>("Id", 0, _HELP("Id for the container")),
InputPortConfig_Void("Start",_HELP("Start iterating")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<int>("Error", _HELP("the number specifies the error - 1: containerId is invalid")),
OutputPortConfig_Void("Done", _HELP("Operation successfully completed")),
OutputPortConfig_AnyType("Out", _HELP("Value from the container")),
{0}
};
config.sDescription = _HELP("This node is used to iterator over containers");
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.SetCategory(EFLN_APPROVED);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig<string>( "Weapon", _HELP("Restrict listening on this weapon. Empty=Listen for all"), 0, _UICONFIG("enum_global:weapon") ),
InputPortConfig<string>( "Item", _HELP("Restrict listening for this accessory. Empty=Listen for all"), 0, _UICONFIG("enum_global:item_givable") ),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig<string>( "Weapon", _HELP("Weapon name on Accessory change")),
OutputPortConfig<string>( "AccessoryAdded", _HELP("Accessory was added. Accessory Name will be outputted.")),
OutputPortConfig<string>( "AccessoryRemoved", _HELP("Accessory was removed. Accessory Name will be outputted.")),
{0}
};
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("Listens for the Player's accessory changes");
config.SetCategory(EFLN_WIP);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void( "Check", _HELP("Trigger this port to check for accessory on the Actor's current weapon" )),
InputPortConfig<string>( "Accessory", _HELP("Name of accessory to check for."), 0, _UICONFIG("enum_global:item")),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_Void( "False", _HELP("Triggered if accessory is not attached.")),
OutputPortConfig_Void( "True", _HELP("Triggered if accessory is attached.")),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("Checks if target actor's current weapon has [Accessory] attached.");
config.SetCategory(EFLN_WIP);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inPorts[] =
{
InputPortConfig_Void( "Enable" ),
InputPortConfig_Void( "Disable" ),
{ 0 }
};
static const SOutputPortConfig outPorts[] =
{
{ 0 }
};
config.pInputPorts = inPorts;
config.pOutputPorts = outPorts;
config.nFlags |= EFLN_TARGET_ENTITY;
config.sDescription = _HELP( "When enabled, combat mode changes the behaviour from trying to strictly follow paths to trying to find the best position in the path from where to engage the target. The default state is disabled." );
config.SetCategory( EFLN_APPROVED );
}
VIRTUAL void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] =
{
InputPortConfig<string>("audioRTPC_Name", _HELP("RTPC name"), "Name"),
InputPortConfig<float>("value", _HELP("RTPC value"), "Value"),
{0}
};
static const SOutputPortConfig outputs[] =
{
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("This node sets RTPC values.");
config.nFlags |= EFLN_TARGET_ENTITY;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig inPorts[] =
{
InputPortConfig_Void( "Enable" ),
InputPortConfig_Void( "Disable" ),
{ 0 }
};
static const SOutputPortConfig outPorts[] =
{
{ 0 }
};
config.pInputPorts = inPorts;
config.pOutputPorts = outPorts;
config.nFlags |= EFLN_TARGET_ENTITY;
config.sDescription = _HELP( "When enabled in combination with combat mode the AI is allowed to shoot at the target. If disabled it just tactically positions itself to places from where it can see/hit the target. The default state is enabled." );
config.SetCategory( EFLN_APPROVED );
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void("Get", _HELP("Get the current Latitude/Longitude")),
InputPortConfig_Void("Set", _HELP("Set the Latitude/Longitude")),
InputPortConfig<float>("Latitude", 0.0f, _HELP("Latitude to be set")),
InputPortConfig<float>("Longitude", 35.0f, _HELP("Longitude to be set")),
InputPortConfig<bool>("ForceUpdate", false, _HELP("Force Immediate Update of Sky if true. USE ONLY IN SPECIAL CASES, is heavy on performance!") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<float>("Latitude", _HELP("Current Latitude")),
OutputPortConfig<float>("Longitude", _HELP("Current Longitude")),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = _HELP("Set the 3DEngine's Moon Direction");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig<EntityId>("objectId", _HELP("Entity to grab")),
InputPortConfig_Void("grab", _HELP("Pulse this to grab object.")),
InputPortConfig_Void("drop", _HELP("Pulse this to drop currently grabbed object.")),
InputPortConfig<bool>("throw", _HELP("If true, object is thrown forward.")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<bool>("success", _HELP("true if object was grabbed/dropped successfully")),
OutputPortConfig<EntityId>("grabbedObjId", _HELP("Currently grabbed object, or 0")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.nFlags |= EFLN_TARGET_ENTITY;
config.sDescription = _HELP("Target entity will try to grab the input object, respectively drop/throw its currently grabbed object.");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void("Poll", _HELP("Poll party info")),
InputPortConfig_Void("Launch", _HELP("Launch match")),
InputPortConfig_Void("Leave", _HELP("Launch match")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void ("Success", _HELP("Triggers if sending succeeded")),
OutputPortConfig_Void ("Fail", _HELP("Triggers if sending failed")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("poll party info for xbox one live");
config.SetCategory(EFLN_ADVANCED);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void("Set", _HELP("Sets the param")),
InputPortConfig<string>("ParamName", _HELP("Parameter name")),
InputPortConfig<float> ("ParamFloat", 0, _HELP("Parameter type in float")),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_Void( "Set", _HELP("Triggers when param set")),
{0}
};
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("Sets post effect param by name");
config.SetCategory(EFLN_DEBUG);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void( "GetGameType", _HELP("Activate this to retrigger relevent outputs")),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_Void( "InstantAction", _HELP("Triggered on level load if InstantAction game")),
// OutputPortConfig_Void( "TeamInstantAction", _HELP("Triggered on level load if TeamInstantAction game")),
OutputPortConfig_Void( "TeamAction", _HELP("Triggered on level load if TeamAction game")),
OutputPortConfig_Void( "PowerStruggle", _HELP("Triggered on level load if PowerStruggle game")),
OutputPortConfig<string>("GameRulesName", _HELP("Outputs the current game rules name")),
{0}
};
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("MP GameTypeNode");
config.SetCategory(EFLN_WIP);
}
//------------------------------------------------------------------------
void CFlowVehicleEntityAttachment::GetConfiguration(SFlowNodeConfig &nodeConfig)
{
static const SInputPortConfig pInConfig[] =
{
InputPortConfig_Void("DropAttachmentTrigger", _HELP("Trigger to drop the attachment")),
{0}
};
static const SOutputPortConfig pOutConfig[] =
{
OutputPortConfig<int>("EntityId", _HELP("Entity Id of the attachment")),
OutputPortConfig<bool>("IsAttached", _HELP("If the attachment is still attached")),
{0}
};
nodeConfig.sDescription = _HELP("Handle the entity attachment used as vehicle action");
nodeConfig.nFlags |= EFLN_TARGET_ENTITY;
nodeConfig.pInputPorts = pInConfig;
nodeConfig.pOutputPorts = pOutConfig;
nodeConfig.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);
}
// --------------------------------------------------------------
void CFlashUIArrayConcatNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "Merge", "Merge the arrays"),
InputPortConfig<string>( "Array1", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
InputPortConfig<string>( "Array2", UIARGS_DEFAULT_DELIMITER_NAME " separated string" ),
InputPortConfig_Void( 0 ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void( "OnMerge", "On merged the arrays" ),
OutputPortConfig<string>( "Array", UIARGS_DEFAULT_DELIMITER_NAME " separated list" ),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = "Merge two Arrays";
config.SetCategory(EFLN_APPROVED);
}
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);
}
