 |
Splinehandles are very good for controlling the back, but also for
making other parts cartoony (for example the fingers or the arms).
first Tip: rotation over the length-achse
The usual way of creating the
splineHandle is - after placing the bones and creating the
SplineHandle - making a cluster of each point of the splineCurve
and then using the clusters to controll the curve.
I`m using this method as well. But there is one thing, that
you should know: with the curve (or the clusters) you can
controll any movements and some rotations, except: the rotation
of the twist-achse. If you twist the curve, the joints will
not twist with the curve (they will move a bit, but...)
You have an attribute called "roll" in the ikHandle.
But I recommend you, NOT to use it, as there is a simplier
way:
put all the joints of the splineHandle AND the curve (or the
controlls) in the hierarchy under one object (mostly another
joint) and with this object, you can rotate it, and if you
made everything correct, it`ll work!
|
|
another Tip:
combining splineHandle with ForwardKinematics
Many animators say: "Don`t give me a splineHandle for the
back, I only animate in FK!"
Actually, a splineHandle is an IK-feature, but you can combine ikSplineHandle
with FK-joints.
Just make an ikSplineHandle with many Joints and one joint-chain
(that you use for FK-rotation) with less joints that are lying as
exactly as possible on the small splineHandle-joints. Take the curve,
that you got from the splineHandle and create clusters of it.
Parent each cluster to the closest joint in the FK-chain.
FINISHED... now you can make some controll-objects for your FK-chain.
another Tip: Twisting from the root (bottom)
in the splineHandle there is a parameter called "Twist".
With this parameter you can twist the joints, so that the rotation
of the first (at the root) is zero, and the more they go up, at
the tip they have the rotation of the Twist-Parameter.
But there is no Parameter for reverse-twist. So that at the tip,
there is twisting of zero, and at the root the twist that we want.
No problem for us. Here comes the solution:
We make a controll called "rootTwist" (a curve, poly or
whatever... has to be aligned to the world-achses), that we want
to use for this twisting and put it at the root of the curve (at
the joint, that is at the bottom). On this rootTwist we parent the
curve or all the controlls that we created for the curve. So - when
you rotate or translate this rootTwist now, the whole splineHandle
with the joints should translate correctly with it. and when you
rotate it at the world-y-achse, it rotates.
Now the point of this solution: We let the "Twist"-Parameter
of the ikSplineHandle rotate reverse to rootTwist, so that the joint
at the Tip doesn`t seem to rotate anymore.
(ikHandle.Twist = rootTwist.rotateY * -1 ... you can do this with
expressions or shadingNodes)
another Tip: scaling the Joints in relation to the curve.
after the first time using ikSplineHandle, you may have noticed,
that - if the curve gets longer, the joints stay in the old length.
No problem for us!
Here the solution:
We just ... scale the joints. Or - in order to prevent the "reverse
Translation" which is explained in the tutorial "autoScaling
Joints" - we translate them.
We have to caluculate the new ScaleX (or TranslateX) with the original
length of the curve and the new length. For getting the length,
we create a curveInfo-Node. I didn`t find a button for it yet (and
I don`t think there is one). So - type: arclen
-ch 1
Now we got a curveInfo-Node. Then we create a multiplyDivideNode,
which we use for dividing the length by the old length. For this
just connect Length from the curveInfoNode to InputX1 of the multiplyDivideNode
and set the Parameter Input2X to the length (so that the values
of Input1X and Input2X are the same, just Input1X is a connection.
Now set Operation of the multiplyDivideNode to Divide and connect
the OutputX of the multiplyDivideNode to the scaleX-Parameter of
each joint of the ikSplineHandle. Finished! If you want to controll
the TranslateX rather then ScaleX, you have to create another multiplyDivideNode
for each joint, in which you multiply the scalefacter (from the
first mdNode) with the old translateX. So you end up with having
a lot of multiplyDivideNodes... except if the translateX-parameter
of each Joint is the same, then you only need one extra Node.
|
 |
