I will be adding actual code under this category … be warned, even though i will try to invent a new wheel, it will take some time probably :). You can grab the script at the end of the post.
This type of script exist for like forever, the only different thing is that ive used vectors to do it, mainly subtraction and scaling of vectors:

#get the joints positions and convert to MVectors
strJntRaw = cmds.xform(startJnt,ws=True,q=True,t=True)
strJntPos = om.MVector(strJntRaw[0], strJntRaw[1], strJntRaw[2])

endJntRaw = cmds.xform(jntChild[0],ws=True,q=True,t=True)
endJntPos = om.MVector(endJntRaw[0], endJntRaw[1], endJntRaw[2])

#subtracting vectors in order to get to the segments position
subJnt = endJntPos - strJntPos

for i in range(1,int(numSegments)):
      newJntPos = subJnt * i * (1/numSegments) + strJntPos

Also, Ive tried to check for the proper orient rotation ( aka the child joint was not moved with Insert and has translation in only one axis) using vectors, specifically getting the norm vector of the child and checking to see if it has 1 on one of the axis. This is done in local space ( it would not work in world).

endJntRaw = cmds.xform(endJoint,q=True,t=True)
endJntPos = om.MVector(endJntRaw[0], endJntRaw[1], endJntRaw[2])
downAxis = ''
endJntNorm = endJntPos.normal()
for i in range(0,3):

if endJntNorm[i] == 1:
       if i==0:
           downAxis = 'x'
           print 'its x'
       elif i==1:
           downAxis = 'y'
           print 'its y'
       elif i==2:
           downAxis = 'z'
           print 'its z'
return downAxis

Download bdSplitJoint.py

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.

Download a copy

Current Address: Villingen Schweningen, Germany

  • Experience
  • 2013, October – Present| Zoobe Messaging Entertainment | Berlin, Germany
    Technical Director for Pipeline:

    – Rigging various biped characters
    – Writing scripting tools to improve the rigging workflow ( PyMel )
    – Animating various characters

    2013, March- 2013, September| Optic Flavor | VS-Villingen, Germany
    Freelance Animator / Technical Animator:

    – Rigging / animating for some pitches.
    2011, September – 2013, February| Acony Games GmbH | VS-Villingen, Germany
    Senior Technical Animator:

    – Creating/managing the animation and rigging tasks.
    – Creating animations for Hedone, an online ‘fps’, rigging realistic human characters and weapons
    – Working with the Unreal Engine 3; creating/managing animation trees, animation sets for the characters and weapons.
    – Creating cinematic sequences in Unreal Editor
    – Python Scripting ( Softimage and Maya)

    2008–2011, September | Acony Games GmbH | VS-Villingen, Germany
    3D Animator:

    – Creating animations for Parabellum, an online ‘fps’.
    – Rigging realistic human characters and weapons
    – Working with the Unreal Engine 3; creating the animation trees, animation sets for the characters and weapons.
    – Creating cinematic sequences in Unreal Editor
    – Python Scripting ( Softimage)

    2006–2007 | Optic Flavor | Bucharest, Romania
    3D animator:

    – Creating animations for commercials.
    – Rigging realistic and cartoony characters ( humanoids and creatures).

    2005–2006 | Dacodac Studio | Bucharest, Romania
    3D Animator:

    – Creating animations for a 3D French TV series called “Adiboo, inside the Human Body”
    – Created an asset management MEL script used to create fast layouts and to properly manage the animation scenes on the next step.

    2002-2005 | Bravo Studios | Bucharest, Romania
    Animation Team Leader:

    – Started as an animator in 2001, evolved to the Team Leader position by 2003
    – As team leader I was in charge of managing a team of 12 people. This included assigning/scheduling the tasks, taking care of them being done on time, supervising the quality of the animation.
    – Worked on Tractor Tom animation series, produced by Contender Entertainment, two series of 26X10 minutes episodes.
    – Other projects included “Brush Head”, a Bafta award winner in 2004, “Toumai, the new ancestor”, a documentary for National Geographic France, “The Fuzz”, fully CGI music clip.
    – MEL Scripting

    2001-2002 | Tiny Creatures | Iasi, Romania
    3D animator:

    – My first job as a 3D animator, acquired after 5 months of training at the same company.
    – I was animating for “Spheriks”, an animated series featuring the official mascots of 2002 FIFA World Cup, produced by Slave Studios UK / FIFA AG
    – Started learning MEL Scripting

  • Education
  • 1995-2001 | Computer Science University | Iasi, Romania
    – Graduated as a Computer Science Engineer

  • Software
  • Maya, 10 years of experience, animation, rigging, MEL/Python Scripting.
    XSI, 4 years of experience, animation, rigging, scripting.
    Unreal Editor, 4 years of experience, animation related knowledge like importing skeletal/static meshes, setting up animation trees, animation sets, creating Physics Assets, creating Morph Sets, creating cinematic sequences
    Adobe Flash, 4 years of experience. Created fully Flash websites. ActionScript 2 knowledge.
    Adobe Dreamweaver, medium knowledge ( created a few websites)
    Adobe Photoshop, medium knowledge

  • Skills
  • Animation – keyframe animation, cleaning motion capture files, using graph editors for manipulating the animation curves, creating looping animations ( both games or as part of a library of motions for animated series), lyp-synch-ing.
    Rigging – wrote a MEL script for generating rigged skeletons based on a custom rig used in one of the companies I worked (Bravo Studios). Good knowledge of human anatomy for creating realistic human characters.
    MEL/Python scripting (Maya, Softimage) – Extensive knowledge of it. Wrote many scripts for speeding various processes ( like rigging) or for assets management.

  • Languages
  • Romanian – Native
    English – Advanced ( living for 5 years abroad )
    German – Basic

    • Game Animation reel 2011-2012

    Game Reel 2012 from Bogdan Diaconu on Vimeo.

    • Mocap clean samples

    Mocap Cleaning from Bogdan Diaconu on Vimeo.

    • TV series reel ( before 2010 )

    Showreel 2010 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.


    © 2019 Moving Pixels Suffusion theme by Sayontan Sinha