Software: Maya
Scripting: PyMel , PyQt
UI: QtDesigner ( for the static part of the interface)
DL: bdAnimCon.rar

What it does:
– Imports controllers and resolves the namespaces
– Dynamically generated UI for controllers
– Easy to add controllers, just a matter of drag and drop in the ‘controllers’ folder
– Color based controllers
– Mirror behavior / orientation
– Proper shape mirroring in case of mirroring with orientation
– Supports multi-shapes controllers
– Supports hierarchy controllers ( fingers for example)

While these days there are a lot of modular rigging tools that bring the animation controllers along, as a TD you still have to rig various things that require ( supposedly) some curves for the animator to grab and move stuff around. And this scripts just does that.

Basically on the same path with the script you need a folder where to drop your favorite controllers as MA files, with the files named so you have an idea whats inside. Why ? The script will look into that folder and use the file names to set the labels for the buttons.

Here’s a link to a demo of it :

Animation Controllers Library from Bogdan Diaconu on Vimeo.


Scripting Language:
what it does:
– helps creating a fully rigged skeleton without facial rigging

Yet Another Rigging Tool …

While i was developing it, from some reason i wanted to create all the animation controllers on the fly .. which i did. Basically they are all box type, with the size of them based on the length of the joint they are driving :). Maybe not the best idea in the world, but hey, it seem like a great idea at that point.
Currently I am working on a Python-ic version of it, more modular and with the help of PyQT / QtDesigner for the interface.

bdYart 0.6 from Bogdan Diaconu on Vimeo.

Maya, QT Designer

Scripting Language:

what it does:
– renames multiple objects using an index based convention

how it does:
– the user needs to select at least one object
– a mask is required for the renaming, with a choice of prefix and suffix too.
– by default the index is 2 digits based ( as in starts counting from 00 to 99). Should the selected object be over 100, automatically 3 digits are used. I assume nobody wants to rename 1000+ objects
– UI is built using QT Designer, but all the events are added in Maya
– the function used to retrieve the widgets paths was written by Chris G.

bdMultiRename from Bogdan Diaconu on Vimeo.


Script Language:

what it does:
– copies mocap data ( imported as fbx file) on rigged characters

how it does:
– opens the fbx file
– cleans up the names
– imports the rigged characters and tries to automatically match up the height of the character
– copies the animation from mocap onto the animation controllers
– removes all the mocap data
– animation now can be tweaked/cleaned/enhanced by the animators
– prepares the file for export

– mocap files were pretty messy, naming wise and structure wise
– a mocap file could have between 1 and 11 players with multiple footballs, the script is handling all the cases
– occasionally the user had to get his/her hands dirty ( like properly naming/duplicating the footballs)

bdFootballUtils from Bogdan Diaconu on Vimeo.


Scripting Language:

what it does:
– keeps track of all the weapon files ( rig files, model files, 1st person view and 3rd person view animation files ) for a FPS type of game

how it does:
– reads the weapon list from an XML file
– based on the above, creates all the paths needed to grab the file names
– uses several filters: character, weapon type, file type
– based on the filters, displays all the files sorted by date ( the most recent on top of the list)


bdWeaponAdmin from Bogdan Diaconu on Vimeo.


Scripting Language:

what it does:
– setups everything needed in regards to adding a new weapon in a FPS type of game

how it does:
– creates the weapon project ( Softimage)
– creates the folder structure for the weapon: the one for the weapon rig, the one for the 1st person view animation of and the one of the 3rd person view animation
– adds the weapon to the XML file that keeps the weapon list
– imports all the weapon parts as obj’s and assigns individual shaders per part
– forces a naming convention
– creates the general skeleton for a weapon and skins the dynamic meshes to those

bdWeaponUtils from Bogdan Diaconu on Vimeo.


Scripting Language:

what it does:
– saves poses using XML files

how it does:
– on the first run the user has to setup a global path for the poses and to add characters
– those above will be saved as user preference and automatically used upon new runs. They can also be modified and the preferences will be updated
– with a character open, the user will have to select the desired controllers
– when the pose is saved, the plugin creates a XML file to store the pose, a synoptic file ( basically an HTML file) that holds the ‘image button’ for the pose and finally a thumbnail preview used in the synoptic file.
– updates the UI with the created pose

PS. Was slightly painful to code the UI due to the dynamic refreshing of it. Also, saving the preferences using softimage’s preferences system is not really friendly, proabably would have been better to save them as an XML file too. Maybe in another iteration

bdPoseLibrary from Bogdan Diaconu on Vimeo.

I have wrote a lot if scripts over the years, from really simple one ( yet useful ) like multi renaming, duplicating, matching positions, to more complex ones like assets management or auto-rigging.

Download scripts

The package contains Maya and Softimage scripts.

Here is a breakdown of the scripts ( you can also find this as .doc files inside the scripts archive)



MEL Scripts


This one creates a fast rig. I made it a while ago and now I am trying to update it and also convert it to Python.

It has the classical 3 chains arms ( one for skinning, one IK and one FK) the switching between being done using driven keys. In the new version it will be done using utility nodes.

This script uses template_skeleton.mel to create the guide skeleton which was created by copy/pasting from an actual maya ascii file the commands.

For the creation of the controllers I basically create them by script and scale them based on the length of the bone is controlling so sometimes it may look funny. Though it is easy to fix it by going in component mode and adjust it.

It does not support scaling this version, which will be included in the Python version. As well a lot of things I want to add in the Python one and make a let’s say “dual” skeleton. One for games and one more TV series/commercials oriented ( with support for scaling, ribbon limbs, stretch and squash, etc). Also a more modular approach I feel is needed.



             This one may be a simple script but it had a lot of usage when I was working for TV series. We had to create a lot of walk cycles where the forward translation was on a WalkMaster. The IK feet would then translate locally being parented under this WalkMaster and in order to have non-sliding feet we were using this script. I have a python version of it made for Softimage since at least for this game I am working the forward movement is the same.

It has two options:

–        create keys from a frame to another ( in case lets say a character turns and a foot has to be planted which means a lot of compensation for the foot hence better results with keyframing every frame)

–        only 2 keys at a source and destination ( when a character moves forward so the feet have compensation only for the forward translation)

It is easy to use and in case an animations needs tweaking its just a matter of re-running the script on the desired frames to correct it.



             I like creating scripts that organize a bit better the work process. This one was created as an organizer tool for the animation/layout/avi’s files for a TV series I worked on (Tractor Tom).

We had an established folder structure and in order to speed up the process of opening/saving scenes I though about this tool. All that an animator had to do was to set the episode/scene/shot numbers from the drop downs and click the needed buttons.

I know that opening/saving files seems like a simple task ( and it is) but when it had to be in a certain format ( the name) on a certain path and there war a lot of shots to be animated per day this helped a lot. 14 people or using it and found it useful.

Along with this script in the folder there are the import audio script, used to import the proper sound file into the proper shot without any browsing.


Python Scripts

             Inside Unreal Engine animations are stored in AnimSets which contain animation sequences. In order to export animation sequences from maya I made this script which basically creates a locator and adds string attributes to it. The name of the attribute is the animation sequence and the value is the range. This attributes are then read upon export and an psa file is created using the name and respectively with the range specified in the attribute.

             This one is a function from the future python rigging script for constraining skinning limbs ( legs, arms, tails, etc) to the ik/fk ones.

How it works: select the fk chain root and the skin chain root and run the script. Repeate with the ik chain root and the skin chain root.

             Instead of using driven keys to create the switch between IK/FK I am using a multiply/divide node.

How it works: select a controller 1st, select the skin chain root second, run the script.

            For the current project I had to create a lot of animation of small flying cameras through the levels.

The pipeline for this was exporting the whole level from unreal, importing it in maya, create paths for the cameras, attaching the cameras to the path, additional animations for the camera ( a ‘fly’ cycle plus animating the camera stopping in certain areas and observing the surroundings) and finally exporting the animations.

So what does the script do:

–        using the Maya’s level tools from bonus tools I would move a camera unreal style and create locators to be used for creating the path curve

–        using the previous created locators create the curve

–        create a path locator and a stop locator

–        create the fly cycle (called swim actually in the script 🙂 )

I am also sending the rig of the camera is using this script DM_Bot_03_Hydra_edit_10.mb. The ‘Body_Anim’ controller has the attribute tail which switches between an IK and an dynamic IK ( using hair) controlling the skin chain. Never mind the mesh, I can’t send the original so its somethinh I came up fast with :).

            And finally this script exports the previous Hydra cam animation for Unreal. The way I am used to work with maya is creating references to the objects that are animated. But to be able to export to unreal I have to get rid of all the namescapes, bake all the animations to the skin bones, get rid of all the extra stuff and finally export.

So this us what it does. From the AnimRanges locator I get the info in regards to the animation sequence range and name.

After that it bakes all the animations on the skiinig bones, importes it locally, rename everything to get rid of the namespace string, delete everything except the mesh and the skinning bones and finally exporting it.

The file is automatically exported using the folder structure here so it will not work by default on another location.

            This one was created for a small freelance project. The client was providing FBX files with multiple character ( football players). The number of characters could vary from 1 up to 11. They could have slightly different heights as well.

This script basically enables the following ( after the fbx is imported in Maya):

–        renames all the characters from the mocap properly ( they are coming from 3d Max and the naming has some issues)

–        import the target animation character and cleanes up all the namespaces

–        duplicates the animation character based in the number of Bipeds and scales them accordingly. The user can still tweak some more the scaling

–        copies all the mocap animation onto the targets animation controllers

–        the user can tweak animations if needed at this step

–        cleanes up the scene by removing automatically all the mocap characters.

–        Bakes the animation and prepares the scene for export by removing everything but the meshes and the joints

–        Images are available in ‘bdCopyMocap_UI’ folder

             Exports all the selected objects to predefined created folders. Used for exporting characters parts and weapons, when weapons are chosen the user has the option of introducing a part of the weapon name which is searched on the folder structure.

Images are available in ‘bdMultiExportObj’ folder.



Python Scripts



When rigging character not in T pose it’s a bit more tedious to place joints. This script comes in handy for this situations by allowing the rigger to set the bone location by selecting 2 opposite edges ( or a whole loop if wanted) and executing the script which will create a locator where a joint can be snapped.



 Utility script used to export skeletal and static meshes from Softimage in order to be imported into Unreal Editor.

The exporter is ActorX. What the script does it allows a faster export of multiple skeletal/static meshes by bulk exporting multiple ones and setting names/paths without having the animator input any data, just select the objects, execute the script and the PSK/PSA files will be exported in the proper folders with the proper names.



Useful for holding the position for IK limbs when animating cycles using a World controller to move the characters.



 Seamless IK/FK and back switch with keeping the position of the hands ( works only for the hands, can be extended for legs too).

There are a lot of scripts that do this for Maya, myself I had to create this for Softimage and dedicated to our rigs. Also worth mentioning that in Softimage there is no need to create the 3 chains ( IK, FK, BIND ) for limbs like in Maya in order to have an IK/FK switch functionality. So this script has to handle only one chain.

The script works for 3rd person view skeleton and for the 1st person view one.



 This script it is used for exporting playblasts as Quicktime movies.

We have multiple animation sequences in one file recorded in a Softimage Custom Property as attributes with the name being the anim sequence name and the value being the frame range.

The user selects these multiple attributes and executes the script which will create all the playblasts and save them in a predefined folder ( in this case the animation folder).

Trying to make the process of rigging a weapon as fast as posible. The script allows to create the proper folder structure automatically, add the weapon to an XML file in order to track it and after properly naming the weapon parts and finally, a rough skinning for the dynamic meshes. The user still needs to tweak the skinning.

Images are available in the ‘bdWeaponRiggingUI’ folder.

             There are a lot of weapons in the current game I am working for ( Bullet Run ) so I have created this script to easily track all the weapons using an XML file.

The user can select a weapon and has the option of opening the weapon rig or the 1st person view animation or the 3rd person view animation. All done without any kind of browsing.

Images are available in the ‘bdWeaponsAdminUI’ folder.



After quite a while I have finally switched to a blog type of site. It is still under construction, need to gather my scripts and rigs and add them here , but I wanted to switch from the ‘ugly’ flash website I had previously to a nicer and cleaner looking one.

Click on ‘About’ to find out some info’s about me, ‘Showreel’ for some animation samples and ‘Resume’, guess what, for my resume :).

© 2019 Moving Pixels Suffusion theme by Sayontan Sinha