C++ Vocab::push_back方法代码示例

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_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_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_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_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;

	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_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_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_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_Bone::get_children_vocab_vfunc() const
{

	LinkableValueNode::Vocab ret;

	ret.push_back(ParamDesc(ValueBase(),"name")
		.set_local_name(_("Name"))
		.set_description(_("The name of the bone"))
	);

	ret.push_back(ParamDesc(ValueBase(),"parent")
		.set_local_name(_("Parent"))
		.set_description(_("The parent bone of the bone"))
	);

	ret.push_back(ParamDesc(ValueBase(),"origin")
		.set_local_name(_("Origin"))
		.set_description(_("The rotating origin of the bone relative to its parent"))
	);

	ret.push_back(ParamDesc(ValueBase(),"angle")
		.set_local_name(_("Angle"))
		.set_description(_("The rotating angle of the bone relative to its parent"))
	);

	ret.push_back(ParamDesc(ValueBase(),"scalelx")
		.set_local_name(_("Local Length Scale"))
		.set_description(_("The scale of the bone aligned its length"))
	);

	ret.push_back(ParamDesc(ValueBase(),"width")
		.set_local_name(_("Bone Width"))
		.set_description(_("Bone width at its origin"))
	);

	ret.push_back(ParamDesc(ValueBase(),"scalex")
		.set_local_name(_("Recursive Length Scale"))
		.set_description(_("The scale of the bone and its children aligned to its length"))
	);

	ret.push_back(ParamDesc(ValueBase(),"tipwidth")
		.set_local_name(_("Tip Width"))
		.set_description(_("Bone width at its tip"))
	);

	ret.push_back(ParamDesc(ValueBase(),"bone_depth")
		.set_local_name(_("Z-Depth"))
		.set_description(_("The z-depth of the bone"))
	);

	ret.push_back(ParamDesc(ValueBase(),"length")
		.set_local_name(_("Length Setup"))
		.set_description(_("The length of the bone at setup"))
	);

	return ret;
}