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 inputs[] = {
InputPortConfig_Void("Trigger", _HELP("Trigger this port to check health")),
InputPortConfig<float>("MinHealth", 0.0f, _HELP("Lower limit of range")),
InputPortConfig<float>("MaxHealth", 100.0f, _HELP("Upper limit of range")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<bool>("InRange", _HELP("True if Health is in range, False otherwise")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.nFlags |= EFLN_TARGET_ENTITY;
config.sDescription = _HELP("Check if health of entity (actor) is in range [MinHealth, MaxHealth]");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig in_config[] =
{
InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Cone")),
InputPortConfig<Vec3>("Pos", _HELP("Centre position of Cone")),
InputPortConfig<Vec3>("Dir", _HELP("Direction of Cone")),
InputPortConfig<float>("Radius", _HELP("Radius of Cone base")),
InputPortConfig<float>("Height", _HELP("Height of Cone")),
InputPortConfig<Vec3>("Color", _HELP("Color of the Cone")),
InputPortConfig<float>("Time", _HELP("Time Cone should be drawn for")),
{0}
};
config.sDescription = _HELP("Draws a cone for debugging purposes");
config.pInputPorts = in_config;
config.SetCategory(EFLN_DEBUG);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig in_config[] =
{
InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Line")),
InputPortConfig<Vec3>("Pos1", _HELP("Start position of Line")),
InputPortConfig<Vec3>("Pos2", _HELP("End position of Line")),
InputPortConfig<Vec3>("Dir", _HELP("Direction of Line")),
InputPortConfig<float>("Length", _HELP("Length of Line")),
InputPortConfig<Vec3>("Color", _HELP("Color of the Line")),
InputPortConfig<float>("Time", _HELP("Time Line should be drawn for")),
{0}
};
config.sDescription = _HELP("Draws a line for debugging purposes. Use either Pos1, Dir and Length or Pos1 and Pos2");
config.pInputPorts = in_config;
config.SetCategory(EFLN_DEBUG);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void("Poll", _HELP("Poll if user is host")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig_Void ("Host", _HELP("Triggers if sending succeeded")),
OutputPortConfig_Void ("Client", _HELP("Triggers if sending failed")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("check if this user is host or client for xbox one live");
config.SetCategory(EFLN_ADVANCED);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void( "Trigger", _HELP("Trigger to restore Player's Inventory." )),
{0}
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_Void("Done", _HELP("Triggered when done." )),
{0}
};
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.SetCategory(EFLN_ADVANCED);
}
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( "DeathMatch", _HELP("Triggered on level load if DeathMatch 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_APPROVED);
}
//------------------------------------------------------------------------------------------------------
void CFlashUIAdvanceNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
CreateElementsPort(),
CreateInstanceIdPort(),
InputPortConfig_Void( "Advance", "Advance the flash player" ),
InputPortConfig<float>( "Delta", 0, "Delta time for advance"),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void( "onAdvance", "Triggered when advance was called" ),
{0}
};
config.sDescription = "Node to advance a UIElement";
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory( EFLN_APPROVED );
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void( "Get", _HELP("Activate this to retrigger relevent outputs")),
InputPortConfig_Null()
};
static const SOutputPortConfig out_ports[] =
{
OutputPortConfig_Void( "True", _HELP("Triggered if Multiplayer game")),
OutputPortConfig_Void( "False", _HELP("Triggered if it is a Singleplayer game")),
OutputPortConfig_Null()
};
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("IsMultiplayer node");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig &config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void ("update", _HELP("Retriggers the entity id. Required for multiplayer")),
{0}
};
static const SOutputPortConfig outputs[] = {
OutputPortConfig<EntityId>("entityId1", _HELP("Player 1")),
OutputPortConfig<EntityId>("entityId2", _HELP("Player 2")),
OutputPortConfig<EntityId>("entityId3", _HELP("Player 3")),
OutputPortConfig<EntityId>("entityId4", _HELP("Player 4")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Outputs the players entity id..");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void ("Open", _HELP("Trigger to open")),
InputPortConfig_Void ("Close", _HELP("Trigger to close")),
InputPortConfig_Void ("Remove", _HELP("Trigger to remove")),
InputPortConfig_Void ("FreeFall", _HELP("Trigger to force Player into FreeFall state")),
{0}
};
static const SOutputPortConfig outputs[] = {
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Parachute ModeControl");
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>( "Destination",_HELP("Destination") ),
InputPortConfig<float>( "Time",_HELP("Duration in seconds") ),
InputPortConfig<bool>( "Trigger",_HELP("Starts the rotation when triggered") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<Vec3>("Current",_HELP("Current Rotation")),
OutputPortConfig<bool>("Done", _HELP("Goes to TRUE when the destination is reached")),
{0}
};
config.sDescription = _HELP( "Rotates between two angles during a defined period of time" );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_OBSOLETE);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_Void( "Succeed", _HELP("Start path ends here and succeed path begins") ),
InputPortConfig_Void( "SucceedWait", _HELP("Optional path that can be triggered after Succeed") ),
InputPortConfig_Void( "SucceedWaitComplete", _HELP("Triggered when SucceedWait state is complete") ),
InputPortConfig_Void( "Abort", _HELP("Abort path begins") ),
InputPortConfig_Void( "EndSuccess", _HELP("Action ends in success") ),
InputPortConfig_Void( "EndFailure", _HELP("Action ends in failure") ),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_config;
config.pOutputPorts = NULL;
config.sDescription = _HELP( "This node is the end point for all the paths in the Custom Action" );
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<float>( "period",_HELP("Tick period in seconds") ),
InputPortConfig<int>( "min",_HELP("Minimal timer output value") ),
InputPortConfig<int>( "max",_HELP("Maximal timer output value") ),
InputPortConfig<bool>( "paused",_HELP("Timer will be paused when set to true") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<int>("out"),
{0}
};
config.sDescription = _HELP( "Timer node will output count from min to max, ticking at the specified period of time" );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void("Show", _HELP("Show mouse cursor")),
InputPortConfig_Void("Hide", _HELP("Hide the mouse cursor")),
{0}
};
static const SOutputPortConfig outputs[] =
{
OutputPortConfig_Void("Done", _HELP("Done")),
{0}
};
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("Node to show or hide the mouse cursor");
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 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);
}
//--------------------------------------------------------------------------------------------
void CSetEquipmentLoadoutNode::GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "Set", "Sets the equipment loadout (only for MP)" ),
InputPortConfig<int>( "pack", "which pack" ),
{0}
};
static const SOutputPortConfig out_config[] = {
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = "MP only: set an equipmentloadout for the local player";
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("In", _HELP("Input")),
InputPortConfig<bool> ( "Closed", false, _HELP("If true blocks [In] data. Otherwise passes [In] to [Out]")),
InputPortConfig_Void ( "Open", _HELP("Sets [Closed] to false.")),
InputPortConfig_Void ( "Close", _HELP("Sets [Closed] to true.")),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Out", _HELP("Output")),
{0}
};
config.sDescription = _HELP("If closed, 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 ( "Enable",_HELP("Trigger to enable the node") ),
InputPortConfig<bool> ( "DelayResult", false, _HELP("Prevents scan from completing normally (Must use Entity:TacticalScanCurrentControl)" )),
InputPortConfig_Void ( "Disable",_HELP("Trigger to disable the node") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void ( "OnEvent", _HELP("Triggered when event with specified entity occurs")),
OutputPortConfig<EntityId>("EntityId", _HELP("ID of the entity that just completed being scanned") ),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.sDescription = _HELP( "Gets the Id of the entity that just completed (But before success or failure) being tactical scanned" );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<bool>( "condition", _HELP("Setting this input to TRUE sends the sleeping condition of the entity to the [sleeping] port, and triggers [sleep] and [awake]") ),
InputPortConfig<bool>( "reset", _HELP("Triggering this input to TRUE resets the node") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<bool>( "sleeping", _HELP("Set to TRUE when the physics of the entity are sleeping (passes the value through)") ),
OutputPortConfig<SFlowSystemVoid>( "sleep", _HELP("Triggers to TRUE when the physics of the entity switch to sleep") ),
OutputPortConfig<SFlowSystemVoid>( "awake", _HELP("Triggers to TRUE when the physics of the entity switch to awake") ),
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.sDescription = _HELP("Node that returns the sleeping state of the physics of a given entity.");
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);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig_Void( "Start",_HELP("Trigger to start measuring") ),
InputPortConfig_Void( "Stop", _HELP("Trigger to stop measuring") ),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_Void( "Started", _HELP("Triggered on Start") ),
OutputPortConfig_Void( "Stopped", _HELP("Triggered on Stop") ),
OutputPortConfig<float>("Elapsed", _HELP("Elapsed time in seconds") ),
{0}
};
config.sDescription = _HELP( "Node to measure elapsed time." );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
static const SInputPortConfig inputs[] = {
InputPortConfig_Void ("Add", _HELP("Trigger to add mode")),
InputPortConfig_Void ("Remove", _HELP("Trigger to remove mode")),
InputPortConfig_Void ("SetDefect", _HELP("Trigger to set mode defect")),
InputPortConfig_Void ("Repair", _HELP("Trigger to repair mode")),
InputPortConfig<int> ("Mode", 0, _HELP("Mode to add/remove"), 0, _UICONFIG("enum_int:Speed=0,Armor=1,Strength=2,Cloak=3")),
{0}
};
static const SOutputPortConfig outputs[] = {
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("NanoSuit ModeControl");
config.SetCategory(EFLN_WIP);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] = {
InputPortConfig<float> ("basetime", 0.0f, _HELP("Set base time in seconds. All values output will be relative to this time.")),
InputPortConfig<float> ("period", 0.0f, _HELP("Set period of the timer in seconds. Timer will reset each time after reaching this value.")),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig<int>("secs"),
OutputPortConfig<int>("msecs"),
OutputPortConfig<bool>("period"),
{0}
};
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
void GetConfiguration( SFlowNodeConfig& config )
{
static const SInputPortConfig in_ports[] =
{
InputPortConfig_Void( "Trigger", _HELP("Trigger the change of team")),
InputPortConfig<int>( "TeamId", _HELP("Change the team (0 neutral, 1 NK, 2 US)")),
InputPortConfig<string>( "TeamName", _HELP("Change the team by name ('neutral' / 'tan' / 'black'")),
{0}
};
static const SOutputPortConfig out_ports[] =
{
{0}
};
config.nFlags |= EFLN_TARGET_ENTITY;
config.pInputPorts = in_ports;
config.pOutputPorts = out_ports;
config.sDescription = _HELP("MP SetTeam node");
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration( SFlowNodeConfig &config )
{
static const SInputPortConfig in_config[] =
{
InputPortConfig_Void( "FlagTutorialAsPlayed", _HELP("Trigger to flag the tutorial as already played")),
InputPortConfig_Void( "FlagTutorialAsNOTPlayed", _HELP("Trigger to flag the tutorial as not played (intended as development tool only)")),
InputPortConfig_Void( "GetFlagState", _HELP("Trigger to get the flag state (played/notplayed)")),
{0}
};
static const SOutputPortConfig out_config[] =
{
OutputPortConfig<bool>( "HasBeenPlayed", "true = already played, false = not yet played"),
{0}
};
config.sDescription = _HELP( "Manages the player profile tutorial flag (SINGLE PLAYER)" );
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.SetCategory(EFLN_APPROVED);
}
virtual void GetConfiguration(SFlowNodeConfig& config)
{
// Define input ports here, in same order as EInputPorts
static const SInputPortConfig inputs[] =
{
InputPortConfig<bool>("Activate", _HELP("Connexion à un server VRPN")),
{ 0 },
};
// Define output ports here, in same order as EOutputPorts
static const SOutputPortConfig outputs[] =
{
OutputPortConfig<string>("Status", _HELP("")),
OutputPortConfig<bool>("A", _HELP("")),
OutputPortConfig<bool>("B", _HELP("")),
OutputPortConfig<bool>("UP", _HELP("")),
OutputPortConfig<bool>("DOWN", _HELP("")),
OutputPortConfig<bool>("LEFT", _HELP("")),
OutputPortConfig<bool>("RIGHT", _HELP("")),
OutputPortConfig<bool>("MINUS", _HELP("")),
OutputPortConfig<bool>("PLUS", _HELP("")),
OutputPortConfig<bool>("ONE", _HELP("")),
OutputPortConfig<bool>("TWO", _HELP("")),
OutputPortConfig<bool>("HOME", _HELP("")),
OutputPortConfig<Vec3>("WIIMOTE_RPY", _HELP("Wiimote Roll pitch yaw vec3")),
OutputPortConfig<Vec3>("WIIMOTE_IR", _HELP("Wiimote IR vec3")),
OutputPortConfig<bool>("C", _HELP("")),
OutputPortConfig<bool>("Z", _HELP("")),
OutputPortConfig<Vec3>("NUNCHUK_RPY", _HELP("Nunchuk Roll pitch yaw vec3")),
OutputPortConfig<Vec3>("NUNCHUK_JOY", _HELP("Nunchuk Joystick vec3")),
{0},
};
// Fill in configuration
config.pInputPorts = inputs;
config.pOutputPorts = outputs;
config.sDescription = _HELP("FG node that sets up a CAVE environment");
config.SetCategory(EFLN_APPROVED);
}
