Post 20 - IK/FK Blending

 

One demo, or training file which ships with the Autodesk Maya Handbook I am currently working through highlights how to create IK (Inverse Kinematic). FK (Forward Kinematic) systems are also described and shown. These are the default system in place when a series of joints are made, which features a predictable hierarchy system. The image shows an IK leg, which has had IK/FK selection enabled. This now allows for the IK to be switched off when key-framing a particular series of movements, so that an FK solution can be used. When this occurs, the IK position is highlighted in a different colour and remains visible until it is keyed back into the solution.

The Graph Editor here shows at what point the IK is disabled (shown using dotted lines). This is fairly logical, but it is worth mentioning that for this IK/FK blending to work, both the IK solver and the joints that will be used for the FK solver must have an active key frame (telling the system to leave the IK control as static in the scene). The IK solution can then be keyed back in at a later point and would continue from where the FK is last keyed in. IK/FK is a great solution to issues of restrictive animation controls or motions. It is the best of both worlds.

A video demonstration can be found using this link: LINK

Post 19 - Joint Rotation Localisation

This procedure is required to understand the essentials of rotational values (both when creating joints and for editing them afterwards). Joint orientation and translation values are stored in the ball spline shapes which sit at the tip of each joint.

Flexibility as These are altered by selecting the component mode (F8). This allows for the joint rotational value to be altered. There is a great deal of flexibility and control over this editing tool as editing joint tips with this mode on means changes to the orientation can be made without upsetting the rig and does not move. By then exiting the component mode, parts of the rig can be rotated and tested. The rule of thumb tends to be to have all vertical joints (spine, legs etc) to have it's Z axis facing the same way (in this case, to the right when looking through the front view). All horizontal joints should have all Y joints facing upward (arms, hands).

However, the exceptions for this are the head, spine tip, ankles and wrists. The reasoning behind this is that these tend to have a different angle and need to be specific to the mesh or model that the rig will eventually control. For example, the wrists on the ZBrush character I am using are at a 25-30 degree angle on both the Z and Y axis and so the joint would have to match these also. The quickest way to translate this information from one side to the other is to simple delete one side and mirror the updated side. This will translate all rotational changes as well as replacing 'Left' labels for 'Right' labels.

Very quick and easy to use. Joints so far seem to be a little more artist / user friendly as supposed to 3ds Max's Bone system.

Post 18 - Maya Rigging - Joints

I have delved into the Autodesk Maya 2010 Modelling and Animation Handbook (Intermediate). So far, I have followed the first chapter on rigging. The technique I am currently addressing is 'joints'. These resemble bones in 3ds Max, but with a name change in theory comes different techniques and approaches. Also, the joints are joined together with spheres (similar to the custom spline controller made in 3ds Max).

The rig I have made in Maya currently has all four limbs, feet, toes, fingers, spine and a head with jaw bone. One interesting difference I have discovered so far is the way in which twist bones are created. In 3ds Max, it is a case of laying a new series of bones onto of the appropriate bone (such as twist bones onto the lower arm). These can be created from scratch, or duplicated from the original bone. With Maya, there is a specific button to press called 'Create Roll Joint'. Then, by dragging across the appropriate bone, this splits it into two and has the rotational properties similar to that of a 3ds Max twist bone (also resembles the refine bone tool). So far, the process has been very logical, and has taken a less time to navigate around. In addition, the use of what is known as the Hypergraph Editor has proven to be a great way of organising and and viewing items in the scene, plus their hierarchy and chains. Here is the hypergraph's interpretation of the scene, which I have broken down with headings (this has been split up into two as the image is long):

Part One

This approach is great for wanting to highlight or select a specific bone and makes the hierarchy visually accessible. Ono top of this, Maya's Mirror joint system is much better at dealing with mirroring rigged items as it allows for re-labelling. For Example, If I have a foot with items all starting with 'LeftFoot', I can tell the mirror tool to replace all of these labels with 'RightFoot'. This saves time and makes the rig overall much more organised.

Note: Clicking on the image will increase it's size and allow for a closer look. Alternatively, I have provided a short video which can be viewed by sleeting the link.

Early joints / rig overview - LINK
Hierarchy view - LINK

Part Two

Post 17 - Failed rigging attempt 'update'

I felt at this point that I should address the problems I came up against as mentioned in my 5th post. I tried to follow a series of training PDFs by Joe Russo. I am now able to create both twists bones and hoe to make a controller which pivots at the bone's orientation. 

Both issues I had from this PDF were combated using the Intermediate Rigging Training DVDs by Paul Neale. A twist bone is most commonly constructed by copying the bone that it will twist along. Then, by refining the bone, this then becomes two. The PDF showed three bones which was confusing, but what was not mentioned wast that first bone was not a twist bone, but the original arm bone, which had been given an edit mesh modifier. The verts for this were then altered to make it tidy. This was not explained very clearly in the PDF, but I have since made them and understand the process. 

Creating controllers and altering pivots points has also since been covered. A spline controller object can have it's pivot point and orientation altered by going into the hierarchy panel, then select pivot point. Then at that moment, you can simply align the spline object the bone, This realigns the object's pivot point and so will now (once linked) could be used to correctly rotate the clavicle bone. These problems have now been overcome through the main rig that I have made.

Post 16 - 3ds Max Rig Additions: Part Two

Still not entirely happy about the joint deformation areas (despite adding muscle bones). These help but do not solve. One method I researched, which is also mentioned on the set of Paul Neale training DVDS is something known as Skin Morphs. The DVDs mentions skin demorphers and is rather complicated as it evolves creating an editable mesh layer for every fix you wish to do. Also, these changes cannot be mirrored which is a massive downside. However, he training DVDs are with 3ds Max 6. Since then, this modifier has come leaps and bounds and as such is now known as simply the skin morphers. Essentially, you set a base (zeroed out) pose at frame 0. Then key in a change in the model which needs attention at a different frame (for example, at frame 50, bend the legs and the crease at the back of the knee). Set a second morph target and this allows you to edit the vertices (also can use soft selection for subtle motion) in a more appropriate position. When done, the modifier will store the difference and conform to this change with any other similar motion.

Left = before skin morph (mesh crashing)                           Right = after skin morph (no crashing)

I find that this is an amazing tool for fixing deforming and problematic areas (back of the knee, leg-pelvis joint, arms and so on). So going back to my previous post, not as much work was needed to be done for prior weight painting steps as any issues could then be fixed using this modifier. Had I of known about this modifier sooner, the work-flow would of taken significantly less time. This modifier can also be used to simulate how skin moves across the surface and how muscles contract and flex when in use. This tool can also be used to mirror the morphs from one side to the next (but in order from this to work, the limbs / area being copied to must be in the exact same position as the initial data).

So, the pipeline for skinning goes as follows:

- Add Skin modifier.

- Edit and scale basic envelopes.

- Bake weighted envelopes.

- Tweak and enhance vertex weighting through direct manipulation and weight painting.

- Key in some animation to analyse skin.

- Tweak and repeat.

- Apply any Skin Morphs for deforming joints.

This has resulted one of many videos. This video is for testing purposes only and so is short and with quick movements. You will notice that the skinning and rig is of a high quality thanks to all the steps and modifiers used.

Here are some useful links I found when researching this technique.

3ds Max Skin Morph video - LINK

Skin Morph information - LINK

Post 15 - 3ds Max Rig Additions: Part One

Sine the last post, I have been spending a lot of time adding the finishing touches to the artefact. I have continued the work of using envelopes for the initial skin weighting. These were then 'baked' into the surface. Once this has been done, The envelopes have no additional contribution and so can be hidden. Vertices were then weight painted for more accuracy and I was able to fix most of the deformation issues (mesh crashing). It was at this point that I added some additional stretchy bones for helping the deformation of the skin (e.g. muscle bones). These were constrained to various influential parts of the torso and leg areas in order to create a smooth muscle like deformation. For example, for the chest muscle, this was position and orientation constrained to both the clavicle bone, as well as the top of the spine. These were then enveloped and weight painted. This allowed for muscles to be simulated and reduced some of the joint deformation as it gave a transitional, middle ground for joints.

Envelopes are very limited in what they can do, however the pipeline of work suggests that using envelopes is merely a stepping stone and a tool for roughing out (this would explain the early, ropey attempts at skinning the Biped rig). Once baked into the mesh, individual points can be weighted more, less or even blended with other verts within the vicinity. With added tools such as mirror envelopes and mirror verts, the process so far has been extremely intuitive and achievable. 

However, with much of the rig itself, this process has taken a very long time and effort in order to accomplish a high quality finished product. Many occasions it was a case of adding and subtracting weight influence in the same area many times over. A quick way around having to manipulate the rig in order to see the effect is by keying in some animations. This gives a must quicker and controlled way of testing any skin tweaks. With time, this process would in theory become more intuitive, but right now, this seems to be the best way of skinning effectively and has a high range of possibilities (only limited by bones).


Demo Clip - LINK

Post 14 - 3ds Max - Skinning: Envelopes

Envelopes

I have begun to explore the skinning of the rig. Using the rig made in 3ds Max, I am using a 'skin' modifier. Then, by selecting each bone, an envelope is assigned to it. I have then started to edit the envelope. As you can see, the amount that the envelope is covering is shown using a colour spectrum. Red mean it is effected 100%. Blue means it is not affected at all and anything in-between is partially effected.

This is very similar to the envelopes that the 'physique' modifier provided when skinning the biped. However, I find that the 'skinning' modifier is a much clearer way of visually communicating the process and should make quick work of the initial phase. I am going to get as far with this as I can with this, but I aim to have it completed by Sunday the 20th of March.

I should point out at this stage that although skinning is a somewhat dark art or skill in its own right, it is important that some form of skinning takes place in order to fully analyse and test any rig. It gives a rig forms and purpose. In addition, I feel that in investigating skinning, it allows me to understand what is needed to be considered when rigging (such as bone position and how this effects the envelope process). I would not consider this to be going off on a tangent and has been factored into the proposed workflow.




Envelope clip - LINK

Post 13 - 3ds Max Bone Rig Summary

Here is the final rig. I plan on skinning it and learning the various methods in the next few days. Overall, I am extremely pleased with this rig as it demonstrates both my ability to learn, as well as another method for rigging. One of the final artefacts may well closely resemble this rig. It is of a high quality and is in fully working order. In my opinion, until it is skinned, I am unable to pass judgement on it fully in terms of its application.

Using custom bones and attributes has much more of an industry presence. Using this method, it allows for the artist to customise the set up for their needs. Also, the rig can be created in different ways and different approaches (spine is a good example). This is a very good system for being able to control a character and again, if it is an animal or fantasy character, the rig can be made for unique specifications

However, although this has clear industry applications and has been seen to be used, the complexity and length of time it took for me to make it was great. Compared to the two days it took the biped to be rigged and skinned, it has taken me about a week to construct the rig alone. A similar method to that of the biped will be used to skin the rig. The next couple of days is going to be spent skinning and learning how to apply the rig correctly. This will be rounded up by the end of the weekend and then an introduction to Maya and it's bone system will take place. As a result of the 3ds Max rig haven taken up a lot of time and effort, the weekly planner is currently out by one week. I have also not been able to research any further into 3ds Max CAT rigging. It is my intention to do so, but this may have to wait until the Easter holidays.

So, I am very pleased, it is of a high quality and is great for custom attributes, flexibility and industry application. However, it is time consuming and requires at times the extensive use of Max Script.


Max Rig 'quick' demonstration - LINK

Post 12- Arm Twist Bones and Hand Controls

I have just finished constructing the twist bones. The twist bones run down the arm and are aligned and linked to the bones they sit on. These are then linked to the wrist control. The orientation constraint is then applied and shared between the two (same as the spine). This allows for the immediate twist bone to twist at 100%, and the secondary one to twist at 50%. The upper twist bone is twisted using additional 'Float Expressions' in order to create a relationship between the elbow control and the clavicle. The controls are then wired to the main waist controller so that when this is moved, the rig moves with it, without disturbing any poses that are present. 

The main hurdle was now creating the bones for the fingers and using MaxScript to create the controls (similar to the foot) First, I used the plugin script known as PEN_ATTRIBUTE_HOLDER. This allows for any spline (e.g. the circle above the hand) to become a store for controls. Once this was established, a series of Max scripted sliders and spinners were made. These were extremely complicated. I cannot take all the credit for this as the DVD set by Paul Neale gives an example of one such control. My job was to now repeat this controller, but for every digit and column.

The final Max Script for the hand digits are is as follows:

ca=attributes HandControls

(

            parameters thumbP rollout: thumbR

            (

                        thumb01 type:#float ui: (thumb01Sp,thumb01Sl)

                        thumb02 type:#float ui: (thumb02Sp,thumb02Sl)

                        thumb03 type:#float ui: (thumb03Sp,thumb03Sl)

                        thumb04 type:#float ui: (thumb04Sp,thumb04Sl)

                       

            )

            parameters indexP rollout:indexR

            (                      

                        index01 type:#float ui: (index01Sp,index01Sl)

                        index02 type:#float ui: (index02Sp, index02Sl)

                        indexSplay type:#float ui: (indexSplaySp,indexSplaySl)

           

            )

            parameters middleP rollout:middleR

            (

                        middle01 type:#float ui: (middle01Sp,middle01Sl)

                        middle02 type:#float ui: (middle02Sp,middle02Sl)

                        middleSplay type:#float ui: (middleSplaySp,middleSplaySl)

            )

            parameters ringP rollout:ringR

            (

                        ring01 type:#float ui:(ring01Sp,ring01Sl)

                        ring02 type:#float ui:(ring02Sp,ring02Sl)

                        ringSplay type:#float ui: (ringSplaySp,ringSplaySl)

            )

            parameters pinkyP rollout:pinkyR

            (

                        pinky01 type:#float ui:(pinky01Sp,pinky01Sl)

                        pinky02 type:#float ui:(pinky02Sp,pinky02Sl)

                        pinkySplay type:#float ui: (pinkySplaySp,pinkySplaySl)

            )

            parameters othersP rollout:othersR

            (

                        cup01 type:#float ui:(cupSp,cupSl)

            )

                        rollout thumbR "Thumb"

            (

                        local fW = 40, oS = [0,-23]

                        spinner thumb01Sp "" range: [-90,100,0] fieldWidth:fW

                        slider thumb01Sl "Thumb 01:" range:thumb01Sp.range offest: oS

                        spinner thumb02Sp "" range: [-90,100,0] fieldWidth:fW

                        slider thumb02Sl "Thumb 02:" range:thumb02Sp.range offest: oS

                        spinner thumb03Sp "" range: [-90,100,0] fieldWidth:fW

                        slider thumb03Sl "Thumb 03:" range:thumb03Sp.range offset: oS

                        spinner thumb04Sp "" range: [-90,100,0] fieldWidth:fW

                        slider thumb04Sl "Thumb 03:" range:thumb04Sp.range offset: oS

            )

            rollout indexR "Index"

            (

                        local fW = 40, oS = [0,-23]

                        spinner index01Sp "" range: [-90,100,0] fieldWidth:fW

                        slider index01Sl "Index 01:" range:index01Sp.range offest: oS

                        spinner index02Sp "" range: [-90,100,0] fieldWidth:fW

                        slider index02Sl "Index 02:" range:index02Sp.range offest: oS

                        spinner indexSplaySp "" range: [-90,100,0] fieldWidth:fW

                        slider indexSplaySl "Splay:" range:indexSplaySp.range offset: oS

            )

            rollout middleR "Middle"

            (

                        local fW = 40, oS = [0,-23]

                        spinner middle01Sp "" range: [-90,100,0] fieldWidth:fW

                        slider middle01Sl "Middle 01:" range:middle01Sp.range offest: oS

                        spinner middle02Sp "" range: [-90,100,0] fieldWidth:fW

                        slider middle02Sl "Middle 02:" range:middle02Sp.range offest: oS

                        spinner middleSplaySp "" range: [-90,100,0] fieldWidth:fW

                        slider middleSplaySl "Splay:" range:middleSplaySp.range offset: oS

            )

            rollout ringR "Ring"

            (

                        local fW = 40, oS = [0,-23]

                        spinner ring01Sp "" range: [-90,100,0] fieldWidth:fW

                        slider ring01Sl "Ring 01:" range:ring01Sp.range offest: oS

                        spinner ring02Sp "" range: [-90,100,0] fieldWidth:fW

                        slider ring02Sl "Ring 02:" range:ring02Sp.range offest: oS

                        spinner ringSplaySp "" range: [-90,100,0] fieldWidth:fW

                        slider ringSplaySl "Splay:" range:ringSplaySp.range offset: oS

            )

            rollout pinkyR "Pinky"

            (

                        local fW = 40, oS = [0,-23]

                        spinner pinky01Sp "" range: [-90,100,0] fieldWidth:fW

                        slider pinky01Sl "Pinky 01:" range:pinky01Sp.range offest: oS

                        spinner pinky02Sp "" range: [-90,100,0] fieldWidth:fW

                        slider pinky02Sl "Pinky 02:" range:pinky02Sp.range offest: oS

                        spinner pinkySplaySp "" range: [-90,100,0] fieldWidth:fW

                        slider pinkySplaySl "Splay:" range:pinkySplaySp.range offset: oS

            )

            rollout othersR "Others"

            (

                        local fW = 40, oS = [0,-23]

                        spinner cupSp "" range: [-90,90,0] fieldWidth:fW

                        slider cupSl "Cup:" range:cupSp.range offset: oS

            )

)

custAttributes.add $.modifiers[1] ca

In Order to get this to work, select the item you wish to make the controller. Then in the modifiers panel select PEN_ATTRIBUTE_HOLDER (However, you may need to download this and save it in the script plugins file in you 3ds Max folder) Then open MaxScript, copy and paste the script above, then on the bottom line, select 'Evaluate All' (Control or Command E). This will then create all the custom spinners ans sliders for a five digit hand (the code may be altered to have less digits, or name changes etc). But note: the item you give the attribute holder modifier to MUST be selected when you so this. This is because in the code, there is the $ symbol. This is basically you telling Max to apply the code to the selected item ($ = currently selected item).

Each bone of each finger were then individually wired to each corresponding slider. This was done using wire parameters as most of the digests needed to be controlled on the Y axis (although the 'cup' and 'thumb' digits rotate on more than one axis).

Very pleased with the result, although it took a very long time and it surprises me that there isn't a quicker way around this. The clip below demonstrates it's movement behaviour.


Arm and hand demonstration clip - LINK

Post 11 - Topology Consideration Two: Arm Position

A second issue with the mesh is the positioning of the arm and hand. As stated in an earlier 'leg' post, in order for an IK Solver to work, the series of bones that it is going to be applied must be aligned on the rotational axis that the bend is desired to occur. The arm of the model up until now has had arms which have been at an angle on more than one axis. The only way the fit the bones inside the mesh is to pay no attention to the IK rule.

To irradiate this problem,the mesh was re-loaded into ZBrush. The arms and hands were then re-positioned into a more rig friendly state. This was then imported back into 3ds Max and repositioned where the previous model was. If this was not done, then when it came to created the IK Solver, the arm would bend at an odd (and unpredictable) angle. The model is now onto version 3.

- Image 1 is the original position of the arm.

- Image 2 is the new position, which from the top view is now in line and can have an arm bone aligned to it.

Post 10 - 3ds Max: Alternative Spine

In order to broaden my knowledge of the possibilities of bones in 3ds Max, the training / reference DVDs provide a different way to create the spine. The basic premise is the same for the original spline, but the first spine was unable to stretch and could only create curves using the spline controls.

This spine has been created by making a spline line. A series of spine bone were then created. point helpers were constrained to the spline line at even points. The bones were then position constrained to the helpers and a look at constrain was applied to each bone. The bones were then orientation constrained to both a spline controller, and another helper (small green cross). The linking was shared between these two (same as the first spine) so that it was a smooth transition of poses. This method allows for more control over the spine as it allows for the same poses by rotating the controls; but allows allows for the spine to be stretched and repositioned. This is great, but the only downside is that there is a lot going on in the scene and so many of the helpers need to be hidden (such as the helpers connected to the spline line).

As seen in the image, primary work has also been done to create an arm.


IK Spline spine clip - LINK

Post 09 - 3ds Max: legs and feet

The next area I created using 3ds Max bones are the legs and feet. These were done using two separate bone hierarchies (one for the leg and one for the foot) and then lining them up together. The leg was given a HIIK Solver (History Independent Inverse Kinematic), which allows for it to be controlled in a reactive way. The foot was given a controller, and then a series of custom controllers were created using MaxScript. It is possible to create menus using the menu creator, but this allows for the menus to be edited at a later date.

One series of 'spinners' and 'sliders' were created for the foot, which was then animated and keyed in a series of pivot extremes. This data was then connected by assigning a 'float reactor' controller. This allowed to connect the motions to the corresponding control. These were then wired using wired parameters and resulted in a foot which can be controlled in the command panel.

Here is the Max Script for the controls ($ = currently selected item):

ca=custattributes.getDef $.modifiers [1].footControls
attributes footControls
redefine:ca
(
    parameters params rollout:footR
    (
    footRoll type:#float ui:footRollSp
    toes type:#float ui:toesSp
    knee type:#float ui:kneeSp
    )
    rollout footR "Foot Controls"
    (
        local range=[-90,90,0]
        group "Foot Controls"
        (
                spinner footRollSp "Foot Roll" range:range
                spinner toesSp "Toe Wiggle" range:range
        )
        group "Leg"
        (   
                spinner kneeSp "Knee" range:range
        )
        group "Keying"
        (
                button resetAll "Reset All"
        )   
        on ResetAll pressed do
        (
                footRoll=0
                toes=0
                knee=0
        )
    )
)
--custAttributes.add $.modifiers[1] ca

The knee on the IK leg currently was determined by the starting point of the end joint. This was changed by telling the IK goal to be the nub of the ankle. This means that the knee now points in the same direction as the foot. However, this was also given an override spinner in the same control panel as that of the foot. Using a 'Float Expression', the leg was also given the ability to stretch (in the event of the animator needing extra flexibility in a scene). This also means that when it is skinned, the mesh would not break.

An important consideration that Paul makes in his DVD is that when making a set of bones with the intention of applying an IK Solver on it, that the rotational position of the two bones are unaltered and straight. If this is not the case, then the IK Solver would want to bend in two different directions (triangle effect). This will be also applied to the arms later on.



: NOTE - CLICKING ON IMAGES WILL GIVE A FULL SIZE OF THE IMAGE FOR CLOSER VIEWING




IK Legs and feet clip - LINK

Post 08 - 3ds Max: Spine Bones

I have started to construct a rig from custom bones with the help from a training DVD series titled 'Intermediate Rig Set', by Paul Neale. This set of training DVDs gives handy advice and methods for creating a detailed and high quality rig. So far, I have created an IK spine. This was created using the bone tools, then refined by the 'Edit Bones' panel. The spine itself cannot be repositioned as the various sections of bone have been linked up the various controllers, which dot around the model. These controllers were simply constructed by creating a spline circle, then duplicating it twice on the other axis. These were then grouped together, resized using the Xform modifier and then converted back into a spline shape.

Each upper most and lower most bone sections have been directly linked to their corresponding controller using orientation constraints (and so will only rotate when the controller is rotated). But for the two middle bones, these have been linked with more than one controller. When this is done, they share the influence from the controllers and evenly distribute it along a series of bones. As one will be effected %65 to a movement, another may be effected only 35%. If the highest spine controller is pulled, the upper area will be affected more then the lower back area, and visa versa.  This allows for a very flexible and yet controlled bone hierarchy. The head bone is directly linked and orient constrained to the controller above it. This results in the ability to control the spine, whilst the head (or eye line) remains intact and unaltered.

The controllers were then linked to the waist control (spline circle). This allows for the whole of the rig to be moved without disrupting the positions of the bones. Advanced versions of this allow for all but the hands to be moved in this fashion. This is good for when the character is required to hold onto an object, but the waist needs to be moved. The hands would remain in the same spot.

FK Spine clip - LINK
Intermediate Rig Set DVDs by Paul Neale - LINK
Paul Neale Wensite - LINK

Post 07 - Topology Consideration One: Joint Edge-loops

One thing I have come up against during the biped rig was deformation of the model around joints that require significant freedom of movement. For example, the shoulders and legs joints would become deformed and stretched when rotated an excessive amount. This was an issue I was previously aware of but until I saw how each area reacted to this, I could not act on it.

The solution to this was the need for extra edge loops where joints were to be manipulated. By adding extra edge loops, around these problematic areas, the envelope's surrounding the biped and model were able to be manipulated correctly. The vertex weighting could be more evenly spread on the surface and so created a much smoother (less stretched) result. This was edited in 3ds Max and will be the model used for future rigs, in both 3ds Max and later on Maya.

Before and After

- Image one is the original model. 

- Image two has had added edge loops around the shoulders.

Post 06 - 3ds Max: The Biped

One method of creating a rig is the Biped rig. This is a pre-fabricated rig, inside of 3ds Max. Additional digits such as the number of fingers, toes and 'knuckle joints' can be added. The user would then scale and fit the rig into the appropriate model. Other basic options include the ability to plan out a walk or run cycle using 'foot prints', which the rig would then follow.

I applied the biped to the ZBrush model. This was scaled to fit inside the model and then attached (or 'skinned') using the 'physiques' modifier. The main method for attaching a rig is known as 'skinning' and usually is done so using the 'skinning' modifier (in other words, the physique modifier is used less and isn't as well known). Once applied, each limb and joint has what are known as 'envelopes', which are pockets that surround the limbs and determine the amount of influence the corresponding limb or joint as over the model (skin to bone). These then had to be tweaked and manipulated in a variety of ways in order to get the desired result (such as parent and child blending, plus positioning and scaling of the envelopes).

When using the biped rig, it is very easy to have an unwanted skin deformation, which looks messy and is certainly not of an industrial quality. 'Fall off' and editing of the vertices' weight would usually reduce this issue, but it was very difficult to irradiate this completely when working on a biped rig (this can be seen mostly on the hip joint connecting the legs). The resulting rig is the first rig I have successfully made and applied to a model. The following is a list of what is controllable for position and rotation:

Head, neck, all fingers and thumbs, hand/wrist, lower arms, upper arms, clavicle, chest, spine (four joints), hip, thighs, lower legs, ankle, heal and toes (toes all move together).

This rig however has only a small amount of IK (inverse kinematic) components; so as a result of this can be awkward to animate. For example, when rotating part of the spine, some parts of the rig are affected by this and other parts are not so much. In addition, there are no controls assigned to the rig, so manipulating the rig is done by freezing the model, so that selecting parts of the biped would allow control over it (although controls are something that I will be covering in due course).

This is a very basic rig and has very little in the way of features. However, as this is my first rig, I am happy with the outcome as it has allowed me to demonstrate one method of rigging. This rig would be most suitable for a very basic/simple biped character, which didn't really need a lot of time spent making every aspect of it perfect. Examples of this could be audience or spectator characters in a racing / tennis game where the attention is not on them, but on the main happenings of the game. The biped rig has been included with 3ds Max for a considerable amount of time, so it can be said (as mentioned earlier) that it is quite dated and isn't particularly used in the animation or games industries. However, in reference to the difficultly and production time, it was very quick to create and size up. The envelopes and skinning took a little longer but overall it took a matter of a couple of days, so this was beneficial and would suit a situation that required a quick mock up or visualisation.

As a result of making this biped rig, I have learnt how to make, scale and skin in 3ds Max on a basic level. I have also been introduced to some useful tools such as the ability to copy joint positioning coordinates and mirror them onto the other side (left leg to right leg, etc). In addition, I have also began to understand the importance of envelopes, as well and vertex weighting and how to manipulate them. The video below shows the skinned rig, although it is quite clunky and is very basic. It also demonstrates problem ears such as the back of the legs, the pelvis-leg join and the arm joints.

Biped Rig / Skin clip - LINK

The next stage is to look into custom bone systems in 3ds Max using the DVD: The Intermediate Rigging Kit by Paul Neale. as reference.

Here were a couple of web links I used to get started with rigging (namely, biped rigging).

3ds Max Rigging Tutorial - LINK
Second 3ds Max Tutorial - LINK

Post 05 - 3ds Max: Bones First Attempt

Character Rigging Workshop PDFs.

My first introduction to rigging began by attempting to follow a set of three tutorial PDF files provided by Joe Russo. These were aimed at teaching how to make and eventually skin an intermediate rig using 'bones'. This featured twist bones, IK (inverse kinematics) joints, and use of layers, freeze tool and bones attributes. I also started to look into creating custom bone controls.

I got as far as I could, but unfortunately I struggled as it is an intermediate tutorial and felt that I was slightly out of my depth. Two areas that I began to fail were as follows:

- Creating twist bones, which were supposed to be over-laid over the original forearm bone.

- Custom control pivot points: altering the pivot point of a control and linking this to a joint, so that it is possible to control a joint positioned at 'A', but with the control's pivot point still residing at Position 'B'. At my current level of rigging knowledge, I was unable to continue on with this.

However, when solutions become apparent, I will address these problems in a later post.

Tutorial PDF - LINK

Post 04 - Proposal Submission

The task one - NSD proposal has been finished and submitted. I feel confident that it is a good piece of work and includes a realistic weekly planner. I will attempt to follow as closely as possible (but I am aware that aspects and areas may change or time).

The next phase is to start following the weekly planner and start to learn the basics of rigging, what is available in the listed software packages and what useful sources and teaching aids there are.

Basic pipeline so far will be:

3ds Max

Biped / CAT / Bones (also bone rigging for face, once Maya rigging is complete)

Maya

Joints / Blend Shapes (facial)

I want to start looking into the various techniques avaliable in 3ds Max, but I am aware (trohugh my research) that Maya has a large presence in both CG film and games industries. For this reason, I wish to look at 3ds Max initially, then move onto joints systems of rigging in Maya. I have chosen to look into facial bone structures in 3ds Max and blend shapes in Maya for a couple of reasons. I wish to look at the two different systems and I want to look at the different methods, so it is an attempt to 'mix it up' a little.