LinkableValueNode::Vocab
ValueNode_GradientColor::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"gradient")
.set_local_name(_("Gradient"))
.set_description(_("The gradient where the color is picked from"))
);
ret.push_back(ParamDesc(ValueBase(),"index")
.set_local_name(_("Index"))
.set_description(_("The position of the color at the gradient (0,1]"))
);
ret.push_back(ParamDesc(ValueBase(),"loop")
.set_local_name(_("Loop"))
.set_description(_("When checked, the index would loop"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Derivative::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"link")
.set_local_name(_("Link"))
.set_description(_("Value to calculate the derivative"))
);
ret.push_back(ParamDesc(ValueBase(),"interval")
.set_local_name(_("Interval"))
.set_description(_("Interval of time to calculate the finite differences"))
);
ret.push_back(ParamDesc(ValueBase(),"accuracy")
.set_local_name(_("Accuracy"))
.set_description(_("Accuracy of the derivative"))
.set_hint("enum")
.add_enum_value(ROUGH,"rough",_("Rough"))
.add_enum_value(NORMAL,"normal",_("Normal"))
.add_enum_value(FINE,"fine",_("Fine"))
.add_enum_value(EXTREME,"extreme",_("Extreme"))
);
ret.push_back(ParamDesc(ValueBase(),"order")
.set_local_name(_("Order"))
.set_description(_("Order of the derivative"))
.set_hint("enum")
.add_enum_value(FIRST,"first",_("First Derivative"))
.add_enum_value(SECOND,"second",_("Second Derivative"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_TimeLoop::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc("link")
.set_local_name(_("Link"))
.set_description(_("The value node to time loop"))
);
ret.push_back(ParamDesc("link_time")
.set_local_name(_("Link Time"))
.set_description(_("Start time of the loop for the value node Timeline"))
);
ret.push_back(ParamDesc("local_time")
.set_local_name(_("Local Time"))
.set_description(_("The time when the resulted loop starts"))
);
ret.push_back(ParamDesc("duration")
.set_local_name(_("Duration"))
.set_description(_("Length of the loop"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Linear::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
Type &type(get_type());
if (type == type_angle
|| type == type_color
|| type == type_integer
|| type == type_real
|| type == type_time)
{
ret.push_back(ParamDesc(ValueBase(),"slope")
.set_local_name(_("Rate"))
.set_description(_("Value that is multiplied by the current time (in seconds)"))
);
}
else
{
ret.push_back(ParamDesc(ValueBase(),"slope")
.set_local_name(_("Slope"))
.set_description(_("Value that is multiplied by the current time (in seconds)"))
);
}
ret.push_back(ParamDesc(ValueBase(),"offset")
.set_local_name(_("Offset"))
.set_description(_("Returned value when the current time is zero"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Linear::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
switch(get_type())
{
case ValueBase::TYPE_ANGLE:
case ValueBase::TYPE_COLOR:
case ValueBase::TYPE_INTEGER:
case ValueBase::TYPE_REAL:
case ValueBase::TYPE_TIME:
ret.push_back(ParamDesc(ValueBase(),"slope")
.set_local_name(_("Rate"))
.set_description(_("Value that is multiplied by the current time (in seconds)"))
);
break;
case ValueBase::TYPE_VECTOR:
default:
ret.push_back(ParamDesc(ValueBase(),"slope")
.set_local_name(_("Slope"))
.set_description(_("Value that is multiplied by the current time (in seconds)"))
);
}
ret.push_back(ParamDesc(ValueBase(),"offset")
.set_local_name(_("Offset"))
.set_description(_("Returned value when the current time is zero"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_IntString::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"int")
.set_local_name(_("Int"))
.set_description(_("Value to convert to string"))
);
ret.push_back(ParamDesc(ValueBase(),"width")
.set_local_name(_("Width"))
.set_description(_("Width of the string"))
);
ret.push_back(ParamDesc(ValueBase(),"zero_pad")
.set_local_name(_("Zero Padded"))
.set_description(_("When checked, the string is left filled with zeros to match the width"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_TimedSwap::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"before")
.set_local_name(_("Before"))
.set_description(_("The value node returned when current time is before 'time' - 'length'"))
);
ret.push_back(ParamDesc(ValueBase(),"after")
.set_local_name(_("After"))
.set_description(_("The value node returned when current time is after 'time'"))
);
ret.push_back(ParamDesc(ValueBase(),"time")
.set_local_name(_("Time"))
.set_description(_("The time when the linear interpolation ends"))
);
ret.push_back(ParamDesc(ValueBase(),"length")
.set_local_name(_("Length"))
.set_description(_("The length of time when the linear interpolation between 'Before' and 'After' is made"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Join::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"strings")
.set_local_name(_("Strings"))
.set_description(_("The List of strings to join"))
);
ret.push_back(ParamDesc(ValueBase(),"before")
.set_local_name(_("Before"))
.set_description(_("The string to place before the joined strings"))
);
ret.push_back(ParamDesc(ValueBase(),"separator")
.set_local_name(_("Separator"))
.set_description(_("The string to place between each string joined"))
);
ret.push_back(ParamDesc(ValueBase(),"after")
.set_local_name(_("After"))
.set_description(_("The string to place after the joined strings"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Logarithm::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"link")
.set_local_name(_("Link"))
.set_description(_("Value node used to calculate the Neperian logarithm"))
);
ret.push_back(ParamDesc(ValueBase(),"epsilon")
.set_local_name(_("Epsilon"))
.set_description(_("Value used to compare 'link' with zero "))
);
ret.push_back(ParamDesc(ValueBase(),"infinite")
.set_local_name(_("Infinite"))
.set_description(_("Returned value when result tends to infinite"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Reciprocal::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"link")
.set_local_name(_("Link"))
.set_description(_("The value node used to calculate its reciprocal"))
);
ret.push_back(ParamDesc(ValueBase(),"epsilon")
.set_local_name(_("Epsilon"))
.set_description(_("The value used to decide whether 'Link' is too small to obtain its reciprocal"))
);
ret.push_back(ParamDesc(ValueBase(),"infinite")
.set_local_name(_("Infinite"))
.set_description(_("The resulting value when 'Link' < 'Epsilon'"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Switch::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"link_off")
.set_local_name(_("Link Off"))
.set_description(_("The value node returned when the switch is off"))
);
ret.push_back(ParamDesc(ValueBase(),"link_on")
.set_local_name(_("Link On"))
.set_description(_("The value node returned when the switch is on"))
);
ret.push_back(ParamDesc(ValueBase(),"switch")
.set_local_name(_("Switch"))
.set_description(_("When checked, returns 'Link On', otherwise returns 'Link Off'"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Range::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"min")
.set_local_name(_("Min"))
.set_description(_("Returned value when 'Link' is smaller"))
);
ret.push_back(ParamDesc(ValueBase(),"max")
.set_local_name(_("Max"))
.set_description(_("Returned value when 'Link' is greater"))
);
ret.push_back(ParamDesc(ValueBase(),"link")
.set_local_name(_("Link"))
.set_description(_("The value node to limit its range"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_DynamicList::get_children_vocab_vfunc()const
{
LinkableValueNode::Vocab ret;
for(unsigned int i=0; i<list.size();i++)
{
ret.push_back(ParamDesc(ValueBase(),strprintf("item%04d",i))
.set_local_name(etl::strprintf(_("Item %03d"),i+1))
);
}
return ret;
}
LinkableValueNode::Vocab
ValueNode_VectorY::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"vector")
.set_local_name(_("Vector"))
.set_description(_("The vector where the Y coordinate is extracted from"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Greyed::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"link")
.set_local_name(_("Link"))
.set_description(_("The greyed value"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Atan2::get_children_vocab_vfunc()const
{
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"x")
.set_local_name(_("X"))
.set_description(_("Cosine of the angle"))
);
ret.push_back(ParamDesc(ValueBase(),"y")
.set_local_name(_("Y"))
.set_description(_("Sine of the angle"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_BoneWeightPair::get_children_vocab_vfunc() const
{
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"bone")
.set_local_name(_("Bone"))
.set_description(_("Bone used to make influence"))
);
ret.push_back(ParamDesc(ValueBase(),"weight")
.set_local_name(_("weight"))
.set_description(_("The relative value of influence of the bone"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_BoneInfluence::get_children_vocab_vfunc() const
{
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"bone_weight_list")
.set_local_name(_("Bone Weight List"))
.set_description(_("List of bones used to calculate the influence"))
);
ret.push_back(ParamDesc(ValueBase(),"link")
.set_local_name(_("Link"))
.set_description(_("The value node being bone influenced"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_SegCalcVertex::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"segment")
.set_local_name(_("Segment"))
.set_description(_("The Segment where the vertex is linked to"))
);
ret.push_back(ParamDesc(ValueBase(),"amount")
.set_local_name(_("Amount"))
.set_description(_("The position of the linked vertex on the Segment (0,1]"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_DotProduct::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"lhs")
.set_local_name(_("LHS"))
.set_description(_("The left side of the dot product"))
);
ret.push_back(ParamDesc(ValueBase(),"rhs")
.set_local_name(_("RHS"))
.set_description(_("The right side of the dot product"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_GradientRotate::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"gradient")
.set_local_name(_("Gradient"))
.set_description(_("The source gradient to rotate"))
);
ret.push_back(ParamDesc(ValueBase(),"offset")
.set_local_name(_("Offset"))
.set_description(_("The amount to offset the gradient"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_BLineRevTangent::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"reference")
.set_local_name(_("Reference"))
.set_description(_("The referenced tangent to reverse"))
);
ret.push_back(ParamDesc(ValueBase(),"reverse")
.set_local_name(_("Reverse"))
.set_description(_("When checked, the reference is reversed"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Scale::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"link")
.set_local_name(_("Link"))
.set_description(_("The value node used to scale"))
);
ret.push_back(ParamDesc(ValueBase(),"scalar")
.set_local_name(_("Scalar"))
.set_description(_("Value that multiplies the value node"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Cos::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"angle")
.set_local_name(_("Angle"))
.set_description(_("Value to calculate the cosine"))
);
ret.push_back(ParamDesc(ValueBase(),"amp")
.set_local_name(_("Amplitude"))
.set_description(_("Multiplier of the resulting cosine"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_TwoTone::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"color1")
.set_local_name(_("Color 1"))
.set_description(_("The start color of the gradient"))
);
ret.push_back(ParamDesc(ValueBase(),"color2")
.set_local_name(_("Color 2"))
.set_description(_("The end color of the gradient"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Or::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"link1")
.set_local_name(_("Link1"))
.set_description(_("Value node used for the OR boolean operation"))
);
ret.push_back(ParamDesc(ValueBase(),"link2")
.set_local_name(_("Link2"))
.set_description(_("Value node used for the OR boolean operation"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Exp::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"exp")
.set_local_name(_("Exponent"))
.set_description(_("The value to raise the constant 'e'"))
);
ret.push_back(ParamDesc(ValueBase(),"scale")
.set_local_name(_("Scale"))
.set_description(_("Multiplier of the resulting exponent"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Compare::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"lhs")
.set_local_name(_("LHS"))
.set_description(_("The left side of the comparison"))
);
ret.push_back(ParamDesc(ValueBase(),"rhs")
.set_local_name(_("RHS"))
.set_description(_("The right side of the comparison"))
);
ret.push_back(ParamDesc(ValueBase(),"greater")
.set_local_name(_("Greater"))
.set_description(_("When checked, returns true if LHS > RHS"))
);
ret.push_back(ParamDesc(ValueBase(),"equal")
.set_local_name(_("Equal"))
.set_description(_("When checked, returns true if LHS = RHS"))
);
ret.push_back(ParamDesc(ValueBase(),"less")
.set_local_name(_("Less"))
.set_description(_("When checked, returns true if LHS < RHS"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_BLineCalcWidth::get_children_vocab_vfunc()const
{
if(children_vocab.size())
return children_vocab;
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"bline")
.set_local_name(_("Spline"))
.set_description(_("The spline where the width is linked to"))
);
ret.push_back(ParamDesc(ValueBase(),"loop")
.set_local_name(_("Loop"))
.set_description(_("When checked, the amount would loop"))
);
ret.push_back(ParamDesc(ValueBase(),"amount")
.set_local_name(_("Amount"))
.set_description(_("The position of the linked width on the spline (0,1]"))
);
ret.push_back(ParamDesc(ValueBase(),"scale")
.set_local_name(_("Scale"))
.set_description(_("Scale of the width"))
);
ret.push_back(ParamDesc(ValueBase(),"homogeneous")
.set_local_name(_("Homogeneous"))
.set_description(_("When checked, the width is spline length based"))
);
return ret;
}
LinkableValueNode::Vocab
ValueNode_Add::get_children_vocab_vfunc() const
{
LinkableValueNode::Vocab ret;
ret.push_back(ParamDesc(ValueBase(),"lhs")
.set_local_name(_("Link"))
.set_description(_("Left Hand Side of the add"))
);
ret.push_back(ParamDesc(ValueBase(),"rhs")
.set_local_name(_("Addition"))
.set_description(_("Right Hand Side of the add"))
);
ret.push_back(ParamDesc(ValueBase(),"scalar")
.set_local_name(_("Scalar"))
.set_description(_("Value that multiplies the add"))
);
return ret;
}