예제 #1
0
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;
}
예제 #2
0
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;
}
예제 #3
0
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;
}
예제 #5
0
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;
}
예제 #8
0
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;
}
예제 #9
0
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;
}
예제 #10
0
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;
}
예제 #11
0
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;
}
예제 #14
0
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;
}
예제 #15
0
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;
}
예제 #16
0
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;
}
예제 #17
0
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;
}
예제 #18
0
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;
}
예제 #23
0
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;
}
예제 #24
0
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;
}
예제 #25
0
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;
}
예제 #26
0
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;
}
예제 #27
0
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;
}
예제 #28
0
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;
}
예제 #29
0
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;
}
예제 #30
0
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;
}