HR - WIP - 030

HR - WIP - 030, originally uploaded by James D Thompson.

Via Flickr:
This is what the spine set-up sphere controls look like. (the joint have been moved for the pic but they lay on-top normally).

This is the same as the other limbs where you are given a "Pseudo" rig to work with that is converted to a rig after your happy.

This has 3 spheres with little tangent spheres in the middle to show the direction of the curve. Unlike other limbs, the user is asked how many joint the want in there spine, then the "Pseudo" curve has the same amount of cv's.

Moving the spheres moves the curve via a smooth skin so the curve eases in and out of the controls for better smooth spine placement.

After the user is happy the curve is converted to joints, to do this it needs to know how many CV's there are on the curve so:

curve.degree + curve.spans = cv count

Now we can run a loop that xforms the position of each cv and makes a joint chain on them.

Now we have a clean joint chain to make a spine from :).

HR - WIP - 029

HR - WIP - 029, originally uploaded by James D Thompson.

Via Flickr:
For most limbs an normal IK will do but for limbs like dog's and horses they have to work a little different.

This is because in human arms/legs the IK would end at the writs/ankle but as the done structure is different in some other animals the IK needs to finish at the Metacarpals.

This is because those animals look like they have a "backwards knee" but intact that's actually there wrist joint and its the Metacarpals that are on the ground.

To make this work a different IK set-up is needed, so for this im using the spring IK. This ik is quite similar but it handles more that one bend better (e.g. the knee and wrist).

HR - WIP - 028

HR - WIP - 028, originally uploaded by James D Thompson.

Via Flickr:
Wooooo,

Got another bit working better.

This node graph is responsible for blending the limb between the pre-set limbs but the new addition to this means the blend in the same area whereas before it just added the two together.

Adding them together did blend but it resulted in the final limb being twice as large.

Form left to right:

The group node to the far left is connected to the GUI, so as the user slides the slider it changes the attributes of this group (0 to 1)

The output of the sliders is input into the blend colour nodes, so if the human slider is set to 1, the human blend colour node blender is 1, which takes the true value (which is the human pre-set).

Then the sum of all these blend colour nodes is fed into an average node which adds them all up.

Then the top average node connected to the start group adds up all the blend values.

This means the 1st multiply divide node takes the output from the pre-sets and divides it but the total sliders, meaning that if 2 sliders are set the the max, the limb is twice as large as before, but now it gets divided by the sum of the sliders, so its reduced back to its normal size.

This means that when you slide up several sliders at the same time the output limb is a mix of them but not the sum, so it all blends in the same area.


The last Multiply divide node multiples the final result by 2, this is because the average node at the top has an added value of 1, this added 1 is to avoid multiplying by zero if all the sliders are set to 0. By adding the 1 and later multiplying by 2, the same result is made but without getting a zero if all sliders are off which causes errors for dividing by 0.

HR - WIP - 027

HR - WIP - 027, originally uploaded by James D Thompson.

Via Flickr:
Just going back through the script and fine tuning and fixing a few areas that have been left.

Now its possible to choose if you want the left, right or both but also mirror your movement from left to right or right to left.

This makes it easy to create symmetrical character or the user can even mirror the movement to get a good approximation, then disconnect the mirror to make them slightly different.

HR - WIP - 026

HR - WIP - 026, originally uploaded by James D Thompson.

Via Flickr:
Now its able to add IK, FK and convert those to stretchy IK and FK.

This was quite hard to set up as im trying to make it as flexible/fool proof as possible, this way the user it able to create IK or FK in any order or even add them after the character has been skinned or even animated.

HR - WIP - 025

HR - WIP - 025, originally uploaded by James D Thompson.

Via Flickr:
:D

This is where the hard work is starting to pay off.

With absolutely no change apart from using "Leg" as the procedures argument instead of "Arm" the whole process of adding IK, FK, Pole vectors, Stretchy limbs and control curves is completely compatible with all "Leg" limbs.

And By "Arm" and "Leg" this is referring to all upper and lower body limbs be that birds wings, flippers horse legs.

For parts like the spine and head the bones are different so they will need there own custom procedure's but those custom procedures will be very small as that will just be using the same procedures that the arm and legs do to convert to joints, set-up the GUI and do all the IK/FK stretch and controls.


making this all procedural and flexible to work with any limb has really saved a huge amount of time as basically one process can be applied to all limbs.

HR - WIP - 024

HR - WIP - 024, originally uploaded by James D Thompson.

Via Flickr:
Top down view of procedural controls.

At the moment im just setting up the procedures to create the stretch, IK and FK but also the procedures to create the controls.

I'm making the controls in there own procedures so the script becomes more fixable, this means I can call the CCTubeControl to make a tube control at any part of the script and use it for anything in that area be that arms, legs or other parts of the rig.

For the FK arms (Tubes) there actually inside a Group that's been rotated to fit the joints, this means that I can have a nice clean 0, 0, 0, in the rotation of the controls but still have the rotation axis in line with the bones.

The next step now is to set-up the IK/FK switch. This is sometimes done by having 3 arms, IK arm, FK arm and another arm that blends between the two.

However for this im quite confident everything is working fine so im going to just set up different constraints and when you blend form IK to FK different constraints blend off or on.

HR - WIP - 023

HR - WIP - 023, originally uploaded by James D Thompson.

Via Flickr:
This is the node graph procedurally generated when applying the stretch to a limb.

Moving from left to right, basically its a distance tool connected to the start and end of the limb,
This tool outputs the length of the arm,
The condition node then compares the distance to a "Stretch start" value (will mention later)
If its larger it will switch the outputs to true (which is is the distance/by "Stretch start" value)

The "stretch start" value is the length of the arm when its fully locked, this means the condition node compares the current length of the arm to the length when its fully locked,

If the distance tool have a value larger than the length of a fully locked arm this is where the stretchy switches on,
So basically the stretch starts when the arm is fully extended.

The final output is linked to the scale X of the joints which just stretches the joint chain.


The multiply/divide nodes basically make sure its a smooth transition,
this means as the arm gets fully locked, the dimension tool and "Stretch start" value are equal,
so dividing these two results in 1,
as it increases its basically stretching the limb in proportion to the "Stretch start" value
Without this the limb would jump a large amount as it would stretch and add the length of the arm as well.

The top left multiply/divide node holds the "stretch start" value,
This will later hook up to the Global controls scale,
This means as the whole rig is scales up, so is the "stretch start" value as the length of the locked arm will be larger due to the arm being scaled up as-well.

Rigging form

Hi, I would relay appreciate it if you could fill out this form on your rigging experience, even if you have little or no rigging experience :).

https://dl.dropbox.com/u/30666061/Masters_project_public/Rigging_form_01.docx

HR - WIP - 019

HR - WIP - 019, originally uploaded by James D Thompson.

Via Flickr:
Added even more functionality to the GUI allowing you to create as many limbs and also delete them if you don't want them.

Here are 4 pairs of different limbs made in under 60 seconds.

Next step is to add the procedures to make the controls and things like stretchy IK and add in the IK/FK blend if the user requires it.

once there added its just a case of the user clicking what they need and should be able to make several limbs fully rigged and fully customizable in minuets :D

HR - WIP - 018

HR - WIP - 018, originally uploaded by James D Thompson.

Via Flickr:
This is the result of the previous image (GUI window).

Here 3 sets of limbs have been made, each with there own names and using the drop down menu at the top of the GUI you can edit each on there own at any time (well any time before there converted to joints).

HR - WIP - 017

HR - WIP - 017, originally uploaded by James D Thompson.

Via Flickr:
Quite a large update that has added a great new feature :D

Now as a user chooses a name and generates the limb, it creates its own script node which it links to.

This also adds the name to a drop down list at the top, this list is above the tabs so it can be used in all tabs. As the user makes multiple limbs, they all get added to the drop down list.

Then if the user selects a different limb in the list it runs a procedure that disconnects the window from all limbs, then attaches to the new selected limb.

The basic idea is, you make as many limbs as you want, then whatever you do in the tabs below (moving sliders and buttons) will be applied to the limb that is selected at the top.

This means you can edit as many limbs on the fly and go back and edit them later even if you have made more limbs since the 1st was created.


Also, the best thing about this is that no global procedures or variables are used and no information is needed to be send out of maya. Also you can save you work, close maya, re-open it and all the values, limb names and attributes are stored which is a section missed by most rigging scripts as they require you to start and finish before closing maya.

HR - WIP - 016

HR - WIP - 016, originally uploaded by James D Thompson.

Via Flickr:
I hear you like limbs, so we put limbs on your limbs :D

Added the dolphin limb and just messing around to see how it copes in strange situations.

Here is a human arm with a bats wing and dolphin arm all joined up just to test how it will work.

HR - WIP - 015

HR - WIP - 015, originally uploaded by James D Thompson.

Via Flickr:
Just adding some more pre-set sliders,

This is the horse legs, to make it blend better though all limbs are in the t-pose so there will be an added section to scale/rotate the limb as a whole

Showreel 2012 James Thompson

HR - WIP - 014

HR - WIP - 014, originally uploaded by James D Thompson.

Via Flickr:
Errors or unexpected things can be good sometimes :P.

I've started on the procedure to converts the spheres the user positions into joints.

For bug checking im trying to do things that your not supposed to, like going back to the first tab of the limb generator and generating new limbs after you have already generated some but this has given a new idea.

If you do go back and generate a new limb it will work and follows the same rules so this could be used to makes a character with lots of the same limbs (like a centipede's legs)


Another useful bug is that when the limb is converted into joints, to make it fast i just run the procedure on the left, then run the same procedure but change the prefix to L, so with this, i might split the left and right up again as the user could click to convert the left but then still edit the right before the convert it. This way if a user wants one limb human and another a wing the can work on them at the same time but still have them different.

HR - WIP - 013

HR - WIP - 013, originally uploaded by James D Thompson.

Via Flickr:
WOOOOO,

Its been a while since the last masters project update and there doesn't look to be much change but under the hood in the code quite a lot has.

The main update since the last is now it has a mirror function, custom name prefix and attachment object.

So now the user chooses a connection object in the list, types a prefix and the limbs are generated and mirrored.

The mirror options are non (no mirroring) symmetrical (which links the right to the left so changing the left will update the right) and asymmetrical (mirrors the limb type but user can move the other limb freely.

Main updates under the hood is mainly making a phalanx (finger) procedure so the fingers are all made in the same block of code, later this will be expanded so every bone is made from this finger procedure.

It seems like not much is happening at the moment but by spending extra time fine tuning means later on I can practically copy this section for the next limbs so in the long run it will be saving some time.

Eye Doctor in the finals!!!

With the completion of the Eye doctor animation it was also nominated for the "Best educational  video 2012" in Optometry today and I'm happy to announce its made it to the final.

Please follow the link for the 4 finals and vote for your favourite :D

http://www.optometry.co.uk/awards/best-educational-video-2012

Website in the making

Hi, not been many updates recently as I'v taken a few days away from my masters project but been doing a little work on a new website. The site is mainly for portfolio work and tutorials and a few updates :).

http://www.jamesdt.co.uk/

Visual Electrodiagnostic Testing Animation

Working in an amazing group of talented people :)

This is a group project with me and some Bradford Uni graduates have been working on as part of the digital media working academy. Working with some really talented and great people David Williams, Arran Hughes, Pauls Kalnenieks, Ravi Kamble Govind & Jason Theaker.