Of course the task of transferring skin weights is nothing new and there are a bunch of solutions already available, yet they all differ in style and approach. Looking into all these tools it also shows that reading and writing skin cluster data has become quite a challenge because no solution seems to be able to break a certain speed limit and working with high resolution meshes speed is the key.

So, I was curious and rather than just grabbing an available tool I felt challenged to work up my own code. I tried various flavours, Mel, Python, C++ and any combination of these but none would go past a certain speed. It’s actually quite interesting how many possible ways there are to read and write skin cluster weight data in the different languages and to compare their affect regarding speed.

Finally, after days of testing and re-ordering the code to squeeze out every millisecond I came up with a python solution on a plugin basis, which is in comparison faster than all the other solutions I have tested. Not by much but still noticable. Reading the skinCluster data is not the problem – depending on the mesh this can happen in a breeze. Reading the file and writing the weights to a new skinCluster is the real bottleneck here. It’s not perfect yet but fast enough to make the process not result in an extended coffee-break.

For example: A mesh with 14566 vertices takes 1.82 seconds to read the weights and write it to a file and 5.87 seconds to re-apply it. The next fastest solution I came across wrote the data in 2.67 seconds and read it in 7.86 seconds. A current test with 22800 vertices took 2.37 seconds to store and 9.84 seconds to read.

As I mentioned before, the tool is not perfect but does the job. It only stores the weights on a vertex id basis. I am aware of the fact that some other tools also allow you to apply the weight by world position but this makes the process even slower and so far we didn’t have the necessity for this option. Maybe I will include it in future versions of the plugin.

Also, if you have a better and faster solution, just drop us a mail.

Download: transferSkinCluster.zip – v1.1

Installation:

Just copy the plugin to your users plugin directory and load the plugin from the Window -> Settings/Preferences -> Plug-in Manager.

Usage:

After loading the plugin you can access the writing or reading of the skin weights data by the command ‘icTransferSkinCluster’. The command must be used with two arguments: The first is setting the mode to either ’0′ for writing or ’1′ for reading. The second argument defines in which order the influences to the skin cluster are given. See the explanation below. Of course you can also setup two shelf buttons with the supplied icons and the following command, which automatically loads the plugin when needed:

if (!`pluginInfo -q -l "transferSkinCluster.py"`) loadPlugin( "transferSkinCluster.py" );
icTransferSkinCluster 0 0; // change the first argument to 1 for read mode

To write the skinCluster data to a file, select your bound model and then select the skinCluster node in the channelBox. TransferSkinCluster needs the skinCluster node selected in order to work. It also exports only the selected skinCluster node. Use the above outlined command or your shelf button to export. The plugin will report a successful export of the weight data. The weight file is stored in the data folder of the current project. It’s a regular text file with a custom extension (.scw).

To re-import the weights just use the read command (icTransferSkinCluster 1 0;). A new window will list all stored skin weights in the data folder of the current project. Just select the data set and click the import button. The weights file contains the name of the bound geometry and the influencing joints, so it is not necessary to select anything. If you apply the weights to a different model, make sure the name matches the one stored in the weights file.

Note on differences in Maya versions:
Because different Maya versions handle the order of skin influences differently it is possible that previously saved weights will be applied in reverse order with a new version of Maya. If you encounter such problems when loading a weights file set the second argument of the ‘icTransferSkinCluster’ command to either 0 or 1, depending on which version the weights were saved with and what the current version of Maya is.

Since transferSkinCluster is a command plugin you can also write your own mel code around it. Use ‘transferSkinCluster -h’ in the script editor for help and usage.

While working on the Maya plugins iDisplace and iCollide I came across the idea for additional deformers. The maya bonus tools 2013 comes with the slide components tool, which allows to slide components over a surface during the modeling process while maintaining the shape (thanks to Steven Roselle for his awesome work). So the idea was to implement this as a deformer when working with animation. I have seen something similar at Chad Vernons site (which btw. is a great source for getting started with the maya API) in his showreel. He also has this sticky lips deformer demo on his site, something that I wanted to do for quite some time now. Since both deformers make use of a control object I thought about combining these two ideas into one deformer.

iSkinDeform is a deformer for Maya which allows to add skin sliding as well as skin attraction effects to a mesh. Skin sliding can be controlled through a control object and keeps the original mesh shape while deforming the vertices over the existing surface. Skin attraction can be useful for applying sticky effects to mesh like to the lips of a character.

iSkinDeform will be maintained for future versions of Maya as soon as they are available.

Supported Maya Versions (OSX and Windows x64): 2012, 2013, 2013.5, 2014

Please note that the windows version is for 64-bit systems only, as I don’t have a 32-bit environment at my disposal.

Download iDeform Suite: iDeform

Installation:

Just copy the plugin to your users plug-ins folder

• i.e. /Users/USERNAME/Library/Preferences/Autodesk/maya/2014-x64/plug-ins

After loading the plugin from the Window -> Setting/Preferences -> Plug-in Manager, the plugin is available through the Animation Menu -> Create Deformers -> iDeform and Animation Menu -> Edit Deformers -> iSkinDeform.

Select an object as a controller, such as a locator, and your mesh object to deform and go to Animation Menu -> Create Deformers -> iDeform -> iSkinDeform Attract/Slide to create the deformer.

Note:

Only mesh objects are supported up to this point.

Parameters:

- Strength: General multiplier for the deformation effect.

- Radius: Defines the distance to the control object in which vertices are effected by the deformer.

- Falloff: Controls the strength of the deformation within the deformer radius.

- Attractor: Let’s you choose between the type of attractor. Choices are ‘Point’ (transforms) or ‘Curve’.

- Pinch: Controls if the affected vertices are moved along their normals or towards the influence object.

- Negative Clamp: This option disables any movement of vertices opposite their normal direction. This feature is beta only as it can lead to unexpected results dependent on the affected area. Must only be used with care.

- Curve Falloff: Controls the amount of influence in U direction when using a curve as a control object.

- Sliding: Switches from the ‘Attraction’ mode of the deformer to ‘Slide’ mode.

- Method: Defines how the position of the moved vertices is calculated. ‘Raycast’ is more accurate but can lead to more overlapping effects when using more extreme positions of the influence object, ‘ClosestPoint’ has less overlapping effects but can be less accurate.

For quite some time I have been looking for a simple collision effect that could be used as a deformer. Unfortunately Maya doesn’t provide such a deformer without having to use soft bodies, nCloth nodes or muscle objects. The problem is that all these solutions are somewhat simulation based and time dependent and are maybe more than is actually needed. Especially when it comes down to an easy task like flattening out a tire or the feed of a character.

The initial idea came from the StretchMesh Deformer made by Kickstand. Their deformer is OpenSource since 01/2012 and it’s a really great tool. I have been able to compile it for Maya 2013 but for some reason the compilation fails for 2013.5. But it gave me the chance to take a look at the code and find out how a mesh collision is actually happening inside a plugin and learn from the pros. Still, StretchMesh has this awesome stretchyness to it and lots of other features.

iCollide is a deformer for Maya which allows to add simple collision effects to a mesh without the need of simulations. The mesh can have simple ground collisions as well as collide with other mesh objects. The deformation can be shaped with a number of attributes and regular curve controls via the attribute editor. The deformation can be either flexible or even kept after the collision for permanent deformation effects. Color controls optionally apply vertex coloring based on the various deformation attributes.

Even if it’s possible to connect several objects as colliders performance may drop with lots of objects or detailed meshes. Also the quality of the deformation effect might be below expectations whenever some colliders affect the same region of the mesh.
For more complex collision effects other solutions might work better but please keep in mind that iCollide was built to serve as a quick collision deformation solution.

iCollide will be maintained for future versions of Maya as soon as they are available.

Supported Maya Versions (OSX and Windows x64): 2012, 2013, 2013.5, 2014

Please note that the windows version is for 64-bit systems only, as I don’t have a 32-bit environment at my disposal.

Download iDeform Suite: iDeform

Installation:

Just copy the plugin to your users plug-ins folder

• i.e. /Users/USERNAME/Library/Preferences/Autodesk/maya/2014-x64/plug-ins

After loading the plugin from the Window -> Setting/Preferences -> Plug-in Manager, the plugin is available through the Animation Menu -> Create Deformers -> iDeform and Animation Menu -> Edit Deformers -> iCollide.

Select your mesh object to deform and go to Animation Menu -> Create Deformers -> iDeform -> iCollide to create the deformer.

Note:

Only mesh objects are supported up to this point.
Collision objects have to be volume objects. Using a plane as a collision object does not work.

Parameters:

- Bulge: Controls the amount of bulging when the collision happens.

- Radius: Defines the distance the bulging effect affects the mesh from the point of collision.

- Offset: Offsets the collision surface.

- Use Ground: Adds a simple ground collision to the mesh. The ground collision effect is calculated before the collision with other collider objects.

- Ground Height: Defines the height of the virtual ground plane for the ground collision.

- Mode: With mode set to ‘Relax’ the mesh will go back to it’s original shape after the collision. When set to ‘Trace’ the deformation will be kept even the surface doesn’t collide anymore.

- Use Start Frame: Defines if the deformation is reset in ‘Trace’ mode when the current time equals the ‘Start Frame’ attribute.

- Start Frame: The frame on which the deformation is reset in ‘Trace’ mode.

- Bulge Shape: Defines the shape of the deformed mesh in the bulging areas.

- Collision Noise: Optionally adds a simple randomness to the deformed vertices of the mesh. Different ‘Seed’ values produce a different offset to the vertices.

- Use Colors: Applies vertex coloring to the vertices of the deformed mesh.

- Result: Defines if the mesh is deformed and colored or only gets the color applied based on the deformation attributes.

- Color Mode: Defines the source for the color effect. The options are ‘Displacement’, ‘Bulge’ and ‘Radius’.

- Max Displacement: Defines the upper boundary when mapping the displacement to the color gradient. This controls how the color from the color ramp is distributed amongst the displaced vertices.

- Scale Factor: This is a multiplier for the for the ‘Max Displacement’ reference value. This can be useful when working with deformations at a small scale.

- Smooth: Averages the color of neighbouring vertices. This feature is ignored in ‘Trace’ mode.

- Default Color: Defines the color for all vertices that are not affected be any collision.

- Color Gain: A multiplier for the color effect.

- Acceleration Range: Maximum distance for closest point calculations for collision points. This value should be kept as low as possible to allow for best performance. It should be increased if the needed collision distance is larger then this value and the affected vertices are moved to the origin.

NEW VERSION!

Just recently I was again in the need for a displacement deformer, but since Maya lacks such a basic deformer in it’s toolset I planned to use the great DisplaceD deformer, available on creativeCrash. Unfortunately the plugin doesn’t support Maya 2013, even though we are already halfway to Maya 2014.

Since I needed a solution I took the chance in looking into the Maya SDK and write a deformer myself. Being somewhat familiar with Python it seemed like a good idea to write a Python plugin, especially because it wouldn’t need a recompile for future versions of Maya. But it turned out that the performance was not as expected and so I took the hard way and rewrote the plugin in c++.
It was not easy but eventually it worked out fine. The first version was nothing big and lacked some features but eventually it has grown into some nice tool. Having the ability to see the displacement in the viewport and not just at rendertime is a great helper at times. Especially when working with environments.

The deformation can be based either on a 2d texture which uses the uv map of the mesh object or a 3d texture node. Additional attributes allow for setting the scale of the displacement and the offset. The dropoff function can be used to limit the effect of the displacement based on a locator position that gets it’s shape from a curve ramp in the attribute editor.

The plugin is comparable to DisplaceD, but it seems that DisplaceD isn’t maintained anymore or at least it hasn’t been compiled for Maya 2013.

If your are looking for a simple displacement deformer, that helps you apply your DEM height map data to your geometry, iDisplace might be the right choice for you. It’s also great to interactively model some fractal shapes based on a 3d texture.

iDisplace will be maintained for future versions of Maya as soon as they are available.

Supported Maya Versions (OSX and Windows x64): 2012, 2013, 2013.5, 2014

Please note that the windows version is for 64-bit systems only, as I don’t have a 32-bit environment at my disposal.

Download iDeform Suite: iDeform

Installation:

———————————————————————

IMPORTANT: Release Note for Version 1.0

If you have used iDisplace before it’s necessary to completely remove the old version in order to make iDisplace work as expected. The old version came with three files, the plugin and two scripts. Simply delete the old files and install the new version.

If you load the new version of the plugin and the old files are still visible to Maya you will receive a warning to remove those files before successfully loading the plugin.

Also note, that the behavior of the plugin can lead to different results compared to the old version. If you use the current version of the plugin with an old scene that was built upon the previous version the displacement result can differ. This is due to some bugfixing regarding the displacement strength and the offset value.

———————————————————————

Just copy the plugin to your users plug-ins folder

• i.e. /Users/USERNAME/Library/Preferences/Autodesk/maya/2014-x64/plug-ins

After loading the plugin from the Window -> Setting/Preferences -> Plug-in Manager, the plugin is available through the Animation Menu -> Create Deformers -> iDisplace and Animation Menu -> Edit Deformers -> iDisplace.

Select your mesh object to deform and go to Animation Menu -> Create Deformers -> iDeform -> iDisplace to create the deformer.

Note:

Only mesh objects are supported up to this point.

Parameters:

- Texture: Links your file texture or procedural texture to the deformer.

- Use UV: Uses the UVs of the object when working with 2d texture nodes.

- Local: Useful when working with 3d texture nodes. Only the placement of the 3d texture is calculated and the position of the object is ignored.

- Scale: Define the amount of displacement applied to the geometry.

- Offset: Moves the affected vertices along their normals to produce an offset effect.

- Type: Defines the direction of the displacement. ‘Normal’ uses the vertex normals for the direction, ‘Placement’ uses the first placement node found in the connected shading graph to modify the ‘Direction’ vector, ‘User’ takes a connected matrix plugged into the directionMatrix attribute of the deformer to modify the ‘Direction’ vector.

- Use Colors (experimental): With this enabled the color of the texture is taken into account for modulating the normals and displacing the vertices. In the current version, there is no real use for this feature but implemented anyway.

- Use Dropoff: Enables the use of either dropoff locators or dropoff curves.

- Dropoff Type: Defines the type of dropoff, which can be ‘Point’ (dropoff locator) or ‘Curve’.

- Radius: The radius of influence when using the dropoff function.

- Dropoff Curve: Defines the amount of displacement originating from the dropoff object within the dropoff ‘Radius’.

- Curve Falloff: Defines the amount of displacement along the U value of the used curve when using dropoff curves or a locator chain.

The color picker in Autodesk Maya still lacks the ability to properly choose colors respecting any linear workflow settings. A current workaround is to introduce a gamma node which can be quite tedious even though a couple of scripts out there can help with the work. But still it results in more nodes being brought to the scene and quick changes in color always require editing of the gamma node.

icLinearColorChooser helps setting the correct colors right in the selected node. It automatically converts selected colors to linear space. It refreshes based on the current selection so that it’s possible to have it open all the time during the setup of shaders.

By default the script assumes that the colors of the given selection are in sRGB space (‘Selection has linear colors’ is checked off). Choosing a color in the UI automatically applies a gamma value of 2.2 and sets the color in the selected shading node.

If a shading node is selected which already has previously colors applied in linear space and need to be adjusted the checkbox ‘Selection has linear colors’ has to be ticked on. This automatically takes the linear colors of the shading node and converts them back to sRGB space so that any adjustments can be made on the gamma corrected version of the color. Any changes of the color will then be transferred back to the shading node in linear space.

Download: icLinearColorChooser.zip

Installation:

Just copy the script to any script directory that is accessed via maya. Run the script by executing “icLinearColorChooser” (without quotes) in the script editor. You may as well build a shelf button for easy access.

We finally made it – brave rabbit’s first renderfarm ‘bunnyburg’ is up and running.

After lots of planning, research, bending metal and drilling holes our six node renderfarm is already crunching it’s way through current renderjobs with 81.6 GHz of renderpower and 96 GB of RAM.

It’s been quite a task finding the right components and making it work because it all needed to fit inside a regular IKEA Helmer cabinet. The idea came from the original Helmer Cluster and the XHELMER while we were looking for ways to build a OS X based renderfarm and it seemed to be the most stylish one too.

Read more about ‘bunnyburg’ on the bunnyburg page.

This tutorial is about how to transfer a custom rig including animation from Autodesk Maya to a game engine such as Unity.

The main problem for this process is that most of what makes up a character rig, such as controls, constraints, connections, expressions will not always get properly imported into the game engine.

One way to get around this is to build a rig that includes only the features that can be read by the game engine, which are usually joints and maybe ik controllers. The downside of using such a limited rig for animation is that the animation process itself becomes a real pain because all the nice controls that can make animating a breeze are missing.

So, how to get around it? The most common way is to have two rigs setup: One for animating, that includes all the controls and one for exporting the animation into the engine, which mainly only consists of joints and the characters skin. This is the safest way to make sure that the transfer works nicely.

When using this two rig setup the animation needs to get transferred from the animation rig to the export rig. And this is done by connecting the two rigs, so that the animation rig drives the export rig which is then baked and exported.
Of course this can be all done by hand but it’s much easier to have some scripts to do all the work and make sure that no errors occur.

The set of mel scripts used in the tutorial can be downloaded here:

icActorTools.zip

This rigging series for maya is the summary of my rigging lectures at the school I am teaching.

I found that complicated workflows such as rigging can be never slow enough when doing it in the classroom. Especially the basics of rigging can be overwhelming for inexperienced users and so I thought I’d put together a series of videos to show how to setup a simple but robust character for animation.

Originally I intended to make it as short as possible as the advantage with such videos is that you can pause at any time and go back if you missed something. But while going through the rigging process it seemed important now and then to explain some steps and shed light on the details. I though hope that everything is understandable and most of all – making sense.

I am mainly focussing on the technical part of the rigging process, even though there is much more to rigging than just the technical side. But I wanted to keep everything as compact as possible in order to supply a good starting point to create a rig from scratch. Still I recommend to also take a look at the various concepts and approaches that stand behind the art of rigging and articulating a character.

The series is meant to be for beginners of rigging as well as lower level intermediate users but of course this depends on your experience.

The rig I am building is far from perfect but includes all the most important features while being fast and robust.

Here is a list of features that is included in the rig I am building:

• IK/FK stretchable back
• FK neck and head
• space switch for the head
• IK legs with knee twisting
• reverse foot with custom attributes
• IK/FK switchable arm
• extra gimbal control for the FK arm
• space switching for the FK arm
• FK finger controls

The final rig will be also available soon for reference. So make sure you check this site from time to time.

Good luck with rigging your character and if you have any questions or find something that you doesn’t work feel free to drop me a mail through our regular website.

Happy rigging!

Downloads

The series uses some mel scripts to make the rigging process much easier. Be sure to download them before starting with the series:

• icStretchSplineIK – build a stretchable spline ik from the given spline ik handle
• icBuildJointControl – build a control shape for the selected joint

Part 1 – Body

1. Creating the joints and setting up the spline IK
2. Setting up a stretchy back for the spine and adding the twist
3. Creating and setting up the FK back controls
4. Finishing the body rig and making the character scaleable
5. Cleaning up the body rig

Part 2 – Head

1. Creating the basic setup of the head
2. Building the space switching for the head and cleaning up

Part 3 – Legs

1. Basic joint and control setup, including the ik handles
2. Creating the reverse foot setup for articulation
3. Finishing with the leg and cleaning up
4. Building a character main control and setting up the body parts visibility

Part 4 – Arms

1. Setting up the joints and adjusting the joint orientation
2. Finishing with the joint orientation and mirroring the joints
3. Building the control joints for the rig
4. Building all the necessary controls for the arm
5. Finishing with the controls and adding the custom attributes
6. Basic rig setup for the arm and building the IK/FK switching
7. Adding the hand to the IK/FK switching
8. Building the orient space switch for the FK arm
9. Adding the lower arm twist
10. Setting up a selection set and controlling the IK/FK control visibility
11. Finishing the arm and cleaning up the scene
12. Finalizing the joint connections and solving rotation issues

Total running time: 05:37h

Quick rendering of an animation we did for a client. This animation was the reason to develop the Quadruped Rigger that is available on our site.

Since the job didn’t include any texturing or rendering we did a quick clay render to showcase the animation.

Linear workflow has already taken its place in our every day work and not too long ago it was a concept that was somewhat clear but also a bit fuzzy to implement in projects at that time. But as the current tools have a much better implementation of linear workflow making the process a lot easier it’s only a question of how well the concept is really understood. Also given the fact that we worked in a non-linear fashion all of our previous lives it calls for bending our minds in a different way that we used to bend it. Of course, everything regarding linear workflow makes perfect sense but sometimes is hard to toss all the old strategies overboard.

During the transition, going from non-linear to linear workflow I often though about how well I really understood everything that is going on behind the scenes and once in a while I came to a point where all this gamma correction and gamma reversing almost broke my brain.

So, the best way I found to deal with these things is to simply try to explain it to someone else. This is actually the most practical way to make sure that you understood something if you succeed to explain it.

Of course there are already dozens of papers out there who deal with the explanation of linear workflow. Most of them are really good but also everyone has it’s own view about it, explaining it from their point of view and personal background. But since I needed to implement the topic in my regular lectures as well as choosing it as the subject for a recent short seminar I needed to come up with my own explanation and view of things.

The downloadable PDF is the compilation of slides that I used for my seminar.

Linear Workflow – deutsch

Linear Workflow – english

If you have any further questions feel free to send me a mail through our regular website.