Code of the Day: Advanced Loft

Advanced Loft 1.0 script by fileadmin: http://www.creativecrash.com/maya/downloads/scripts-plugins/modeling/misc/c/advanced-loft

Advanced Loft 1.0 is a lofting tool for creating and attaching lofts between two NURBS curves.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 142

Functionality: 6
The function creates a loft between 3 NURBS surface curves and creates a slider for each of the lofts created for additional adjustment. This is really the barebones of the functionality, and it would be nice to have a few more options if using the tool.

Design: 4
The design is straightforward and while the functionality of creating the loft is somewhat separate, it would still benefit the overall structure to have it completely remove from the interface creation code. There are a few places where it seems that basic API functionality is not used (like looping through the selection list and incrementing a counter to get the size of the list, rather than using the MEL command "size").

Style: 5.5
The code style does not seem to use much indentation and in a few places makes it difficult to read. The code naming conventions are decent and it does make use of comments in a number of places.

Documentation: 6
The code documentation is sparse, but useful where it exists. Some additional information about how the tool is supposed to be used would be helpful, as would a little bit more code documentation of how it is supposed to be used.

Reusability: 6
The script size is very small, which makes it easy to extend and grow if necessary. Some additional cleanup may be worthwhile if heavy maintenance is required, but overall the code is so small it could be entirely refactored if so desired.

Overall: 5
The code focuses on doing one thing, and the end results are alright, but only fills a very specific niche for this functionality. A few extra options would benefit it somewhat, but otherwise it give interesting results.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Ya Selection Manager

Ya_SelectionManager 1.7.0 script by yashu: http://www.creativecrash.com/maya/downloads/scripts-plugins/modeling/misc/c/ya_selectionmanager--2

Ya Selection Manager 1.7.0 is a tool that adds a menu to the ChannelBox that allows selections to be saved and loaded. The saved set can be named or deleted through the interface.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 397

Functionality: 7
The functionality is quite nice, although it seems to only work with older versions of Maya (likely due to changes in name from Maya ChannelBox in the newer versions. The selection options are quick and easy to use, and give functionality that would likely be very useful to have built into Maya.

Design: 7
The code design is decent, although it does not work in newer versions it is often difficult to predict how changes will occur through versions, and does not appear to have any obvious version dependencies. The code uses magic strings as parameters variables to use in if else statements, which may be useful to look at another less error prone approach.

Style: 6
The code style is a little inconsistent, with a number of areas that would benefit from a bit better spacing and organization. Overall, the code would benefit from more internal comments and perhaps a little bit more consistency with spacing from the scope of the function.

Documentation: 7
The code documentation has a long header with quite a bit of information and comes with a readme file which helps describe how to setup the script and how it is supposed to be used. A little more internal documentation on what the functions are doing would be helpful, but otherwise the rest of it is quite well done.

Reusability: 6
The script is tiny, but already suffers from some compatibility issues with newer versions. The fixes would likely involve modifying the code that interacts with the ChannelBox, and this may require some additional logic in other places if the changes cascade down the line. The code shouldn't be too hard to update or rework, but still the initial problems are a bit of a warning sign.

Overall: 6.5
The tool works well in older versions of Maya (2008), but has issues with newer versions (2012). Overall, the script gives a nice feature that is often wrapped into pose selection libraries, but does it in an easy and elegant way that works quickly and easily with many workflows. I would not be surprised to similar functionality eventually becoming built in, but in the meantime, this is a nice tool for speeding up using selections.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Clay Dough Mel

clay_dough.mel 1.5 script by man0war: http://www.creativecrash.com/maya/downloads/scripts-plugins/c/clay_dough-mel--2

Clay_dough 1.5 is a tool for emulating magnet fall-off deformers, creating a clay-like process for modifying geometry.

Language: MEL
Type: Maya Editor Script
Script Files: 3
Number of lines: 1681

Functionality: 9
There are not a lot of functions, but the end result is quite impressive and really does make the selection move and feel like clay. I think this is a very nice approach for working and creating non-uniform organic forms, and can rapidly generate some interesting selections to stretch and squash polygons, nurbs, lattices and curves. There are also options for installing the shelf, but the real result is the clay dough effect.

Design: 6.5
The code is quite logical in its file separation, and each function set it nicely encapsulated within each of the files. The function length on a number of the clay methods, is a bit long, but overall are fairly self contained. The nesting depth of some of the function logic was quite long, and some of the loops within loops would make the algorithmic performance suffer (in a few places the nested loops were 8 loop levels deep) meaning on a very large data set this would not scale very well.

Style: 7.5
The code style is actually pretty good, and is spaced and commented in a consistent manner. The naming conventions used and commenting were in a few places a little unusual, but overall the style of the code would benefit a bit from smaller functions design as the individual pieces are fine, but when put on a large deeply nested function, end up adding large comment blocks to break up the code logic instead of just separating out the function.

Documentation: 8.5
The code documentation is pretty good, although there is a number of places where there are significant comments after the main functionality of the code, which is a little unusual (usually all the information is in the header). The separate documentation is nicely formatted html with lots of pictures and helpful guidelines on how to use the tool and install the shelf button.

Reusability: 7
The script size is not massive, but there are not a lot of standalone functions that could be used in isolation. The code in a few places is a little too nested which could make updates and bug-fixes more difficult to test and apply. The script comments and style do help maintain the structure, but likely new features or fixes would prove to be a bit time consuming from the design of the code.

Overall: 8.5
The tool does one thing really well and that is great. I was actually impressed by the results, as I did not expect to see such clay-like deforms happening so smoothly when I first tested the tool. Definitely a tool to check out for its functionality, although it would rely on a particular workflow for an artist to use it regularly (it is fun to play around with though).

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Non Photo Realistic Shading Maya

Non Photo Realistic Shading Maya 0.7.0 script by yinako: http://www.creativecrash.com/maya/downloads/scripts-plugins/rendering/misc/c/non-photo-realistic-shading-maya

Non Photo Realistic Shading Maya 0.7.0 is a script to setup shading networks for a anime/toon look, by using a series of ramps.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 198

Functionality: 6.5
The script offers a few options: name of the shader, bright and dark colors, the number of color bands, shading type and building the specular. Some additional options would be nice (such as choosing a few extra colors (perhaps highlight color, a few middle colors and shadow color) but otherwise can give some good results with what is available.

Design: 6
The script is only two functions (one for UI, one for processing UI and creating the shader network). The first function is fine, but the second function may benefit from being broken up into separate functions. The creation and joining of the specular node could easily have been a separate function instead of a long if statement. By having everything in the main process function, it introduces a lot of variables as well for such a small script.

Style: 6.5
The code is well commented, and makes good use of whitespace and appropriate variable names. It would benefit from creating separate functions instead of using comment blocks to separate logic, but in such a small script it is hard to rate that too heavilty. There are a few magic numbers (especially in the creation of the spec ramp) which may be nice to add as options to the UI instead of being hardcoded into the script.

Documentation: 7.5
The documentation is easy to follow and provides a good amount of information. The source code has quite good comments as well, and makes it easy to follow what the code is doing as the comments are pretty descriptive.

Reusability: 7.5
The script is tiny and thus would be very simple to maintain, however it would require some additional work to extend functionality, and would benefit from some additonal separation of logic. The creation of the shading network is fairly self contained (as the function takes no parameters), however, it would be fairly easy to refactor this code to make it more extendable, based simply on the size of the code base.

Overall: 6.5
The script is small but gives a nice starting point for anime/cartoon shading using ramps. Likely it would be more useful with a few more options, but as it stands, the results are pretty good, and would work for a certain look.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: AniMan

AniMan 1.4 script by manus: http://www.creativecrash.com/maya/downloads/scripts-plugins/animation/c/-animan

AniMan 1.4 is a toolset for creating procedural and rig skeletons through a UI interface. It has a number of options that are unique to the tool, such as adding wing, tentacle or tail rigs, options to create 2 or 4 arm rigs and a few more options. It is also interesting in that the majority of functionality is not a completely separate interface but is built into the ChannelBox.

Language: MEL
Type: Maya Editor Script
Script Files: 137
Number of lines: 23164

Functionality: 7.5
There are lots of functions and a number of unique features which is interesting to see. Unfortunately, with so many things in the tool, it does not give very much information about how to guide the user, and the error messages are not very clear about what mistakes where made (usually involving something like a "Error: No object matches name: " which sometimes causes the progress bar to also freeze). The tool also has a pose library which also would benefit from some better debug messages to help guide the user in what mistakes they are making (or where in the code to look).

Design: 6.5
The code is broken up into a number of files, and while I do think this is a better design than a monolithic approach, it seems like a number of files only contain a single function, and in some cases the function body is a single line. While the focus on small functions is ideal, so is grouping logical functions together in the same file. For example, all standalone string manipulation functions, all LegIK, or BackFK, or ArmIK could be grouped together in the same file, especially since there is a number of areas of code duplication between the files.

Style: 7.5
The code style is pretty good, although I find the commenting structure a bit odd (where the comments are not nested with the same spacing as the rest of the code), but otherwise fine. The code does make use of mostly small functions and does a good job of commenting the code internal workings, and uses good descriptive names for variables and functions.

Documentation: 6.5
The code documentation is good, but with the website down, it makes it more difficult to understand how the functionality is supposed to be used. Overall, the code gives some good info into the structure, but would also benefit from giving some more explicit error messages to the user to help guide what went wrong.

Reusability: 7
The script would likely be easy to maintain once you had a better handle on what every file does. The code base isn't huge, and for the most part has a number of areas that could easily be reused. Global variables are kept to a minimum and there is a good separation of logic between the UI and rest of the functionality. As I mentioned there is a bit of code duplication which may result in the same bug fix in a number of places, but otherwise is fine.

Overall: 7
The tool offers a number of intersting functions and has some powerful features. This is a toolset that does require a bit of a learning curve to figure out how it is supposed to be used, but the results are interesting and does offer some unique attributes not seen in other pieces. With a little more guideance to minimize user's ability to make an error (or guiding them through their mistakes) it would be quite a useful tool, although I realize the ChannelBox approach might not be everyone's favorite.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Pose 2 Shelf

Pose 2 Shelf 1.1 script by boymaya: http://www.creativecrash.com/maya/downloads/scripts-plugins/c/pose-2-shelf

Pose 2 Shelf 1.1 is a script that allows the artist to save either selection information or set attribute information as a button on the shelf.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 204

Functionality: 7
There are really only two major functions in the UI (with the option of adding a label), but the script is quite powerful in that it gives a nice and quick to use result.

Design: 8
The code has a bit of duplication in the creation of the shelf buttons and moving some of the additional checking code could be even more concise and reusable if the duplicate code in creating the shelfbutton was moved to a separate function. Otherwise the code does a good job in keeping the logic into appropriate functions and encapsulates the functionality well in each of these.

Style: 8
The code style is pretty structured and the use of whitespace and comments is quite consistent. There are a few places where a bit more or less empty lines may help improve the spacing of the code, but otherwise it is quite well done. A few additional comments in the code would be nice, but otherwise is quite good.

Documentation: 6.5
The code documentation is ok is simple and effective. Some additional comments in the code would be nice, and while the use of ALL CAPS in the documentation is a little unusual, it is eye catching for those that only glance casually at the content.

Reusability: 8.5
The script is tiny and powerful, with a little additional refactoring, it is likely this script could be even smaller and more powerful. Maintenance on this code would be very easy, as it is quite logical and is great in it separation of interface and the rest of the code logic.

Overall: 8.5
The code is pretty powerful and offers a nice option for those looking for something lighter and simpler than the complex selection and pose libraries from other solutions. If you need to create a lot of selections or poses it may not be the best approach as the shelf will grow very quickly, but for quick and rapid use, it is very nicely done.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Make Fire

Make Fire 1.0 script by nc16: http://www.creativecrash.com/maya/downloads/scripts-plugins/dynamics/c/make_fire--2

Make Fire 1.0 is a quick and easy script for adding a nice fire fx to a surface object.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 139

Functionality: 6
There are very few options (initial size and resolution creation) as well as a simple help option, but the end result produces a nice result attached to a surface object. In some ways the script does not need all the functionality as the fluid node that is created makes it easy to use.
For some systems, if you get the error: "Cannot find procedure "create3DFluid" you may have to source the file before running the script.

// Run the following code before sourcing (or after resourcing the make_fire script)
source "create3DFluid";

Design: 7
The design is quite straightforward, and at such a small file size does a good job of making it quite easy to use. The functions are separated to make the each entry encapsulated, and does a pretty good job of separating most of the UI from the from the rest of the code, but it would be even nicer if the code was entirely separate (grabbing the UI values and passing them into a separate function rather then within the same function). The script does use a lot of magic numbers which while give a good result, are not quite as maintainable as parameters or variables.

Style: 6.5
The naming conventions are pretty good, but unfortunately the spacing and whitespace usage are quite inconsistent and just becomes a bit muddy. The overall elements and use of comments make it fairly clear to read, and with such a small code base every issue is a bit more magnified since it is hard to consider these anomalies.

Documentation: 7.5
The code documentation is quite straightforward and comments most elements of the code in a helpful way. The header comments are straightforward and to the point and the help menu is useful, even though it uses fairly casual language and format.

Reusability: 7
With only a few functions and very few parameters it would require refactoring to extend or reuse any functionality. In terms of maintainability, the script is tiny, which makes it very easy to maintain/debug or update as necessary.

Overall: 6
The script produces a nice result, although I imagine that some presets would also produce something similar. The attachment to the surface is a fine approach, and overall the script does a nice job. It would be nice to have a few additional options, but otherwise is short and sweet.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Puppet Master

Puppet Master 1.7.0 script by blackholestudios: http://www.creativecrash.com/maya/downloads/scripts-plugins/character/c/puppet-master--2

Puppet Master 1.7.0 is a biped rig creator which uses locators to map out the joints.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 4507

Functionality: 7.5
There are only a few options (IK/FK, stretchy spine, strechy arms, strechy legs) and options for naming the character, but the end result produces a nice fairly complex rig. There are a number of additional tools and options once the rig has been created (for setting up different controller (eye, hand, foot etc.) as well as options for moving and rotating the controls.

Design: 4.5
Simply put the main "BuildRig" function totaling 3772 lines and having ~200 unique variables is massive. Unless this was done in an attempt to significantly optimize some piece of the design that I am missing, it makes this script very, very difficult to follow and makes the overall code become incredibly complex from this design. This is not the only function in the program, but it makes me wonder why such a complex lengthy function is used as the rest of the functions seem to have a singular purpose and be better encapsulated.

Style: 5
The code variable names are appropriate, and the code uses comments to help organize areas of the code. The spacing is a little inconsistent however (both tabs and spaces) and a number of places have very large indentations (ending up 32 spaces deep for one level of nesting). The code would benefit from breaking apart the large function (perhaps into separate files even) and there are a number of areas where closing brackets are used at inconsistent column placement to help try to organize logical breaks in the code, but this often makes the reader wonder where the closing bracket for the statement is located when the column spacing of the end bracket does not match up (and is instead lined up with a higher level scoping.

Documentation: 7
The documentation is easy to setup, and there are a number of comments throughout the code (which also serve as logical breaks when reading the function(s)). A little additional commenting would be useful, as especially in areas where there are so many things happening at once. I was unable to find the links to the documentation mentioned in the code, so won't post them here, but it would be nice to see what additional information was available for this script.

Reusability: 3.5
This script is very difficult to follow with so much going on in the main function, and thus it becomes very difficult to update or maintain. With so many variables at play, and so many attributes being created and set, debugging any issue would become very problematic and may require a lot of print statements (as can seen by the commented out print statement in a few places).

Overall: 6
A few additional options would be nice to have, and I am curious about the vehicle rig mentioned as "Coming Soon". The use of locators to place the rig points is a good approach, and the end resulting rig is quite complex and interesting. Some additional options would be nice to have, but otherwise this script gets by more on its end results then anything else.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: AutoSave

AutoSave 1.0.4 script by NicoMaya: http://www.creativecrash.com/maya/downloads/scripts-plugins/interface-display/c/auto-save

AutoSave 1.0.4 is an option for enabling a scriptJob to fire on "selection change" or "recent command change" and options for how many hours, minutes and seconds to perform and autosave.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 379

Functionality: 8
The options are useful, and the ability to set such specific increments of time makes the script quite useful for artists that have different work schedules, or allowing it to be tweaked for certain types of work. The use of scriptJobs is expected here, and the code base is quite good about checking for its use.

Design: 7
The structure of the code is quite organized, although a few functions appear to do a little bit more (or in some cases less) than I would expect. The code base is quite organized, although in a few cases I felt that the use of eval may not be necessary, and would make the code a bit easier to follow.

Style: 8
The code is quite organized, and the use of whitespace makes the code easy to follow. There are a few areas (such as the use of cases with 0, 1, 2) that could be a bit more descriptive, but the variable names are descriptive and appropriate. A few areas of the code would benefit from additional comments. but the overall structure helps reveal the structure of the code.

Documentation: 8
The documentation is quite easy to follow and has information for various operating systems, which is helpful. It would be helpful to have additional comments within the code, but the code base is quite small and functions fairly descriptive so it is not quite as necessary.

Reusability: 8
The use of scriptJobs and evals makes the code more difficult to reuse in parts, but a few areas are quite logical and would be easy to maintain. Additional comments would help make the code easier to maintain, but with the code base being so small, it would not be much of a problem.

Overall: 7.5
The functionality is quite helpful for those looking for an auto save, and has some nice features in setting the time which would certainly help different people who work at different speeds. Some additional options for doing auto incremental saves would be nice to have. The use of selection or tool change is a good approach, although in python a threaded approach may also be an optional and perhaps more consistently timed way to approach the problem.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Tree Generator

Tree Generator 1.4 script by nitisara: http://www.creativecrash.com/maya/downloads/scripts-plugins/modeling/misc/c/tree-generator

Tree Generator is a nice option for random generation of NURBS trees. There are quite a number of options to create the trunk, roots, branch and adding leaves from a Maya.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 1151

Functionality: 9.5
The tool creates a number of options to create a nice tree, with quite a number of options to generate the random tree. The code does generate a lot of NURBs objects, which would be nice to either combine or have options to generate polygons instead. The tool allows quite a bit of functionality in terms of customization and extension, and it allows custom leaves to be created and used. The option of loading and saving presets is especially powerful, and the tool comes with a number of useful options for creating trees.

Design: 7
The code base is fairly small but powerful. The code does however make use a significant amount of global variables (counted at least 66), and would benefit somewhat from additional encapsulation. The tool creates a new scene each time which is a little unusual, and while the animation in producing the tree is neat to see, I would prefer that the tool have options to disable this as well. Some of the code seems to do quite a lot, and some smaller more encapsulated functions would help benefit the structure.

Style: 8.5
The code makes quite good use of whitespace and the variable names were quite appropriate and easy to follow. In a few cases the same variable name was used for different values (mostly in loop iterators) but otherwise is pretty good.

Documentation: 9
The documentation is quite helpful and explains all of the options in the UI. There Readme.txt was helpful and gave a good overview of the overall functionality of the code.

Reusability: 6
The code is tightly coupled to the UI and has a significant number of global variables (although most are treated as constants). The code makes use of a number of switch statements which is what makes the code more difficult to extend or change.

Overall: 9
The functionality produces a nice result, although with a few tweaks additional options on the type produced (combined polygon mesh would be nice), and the ability to turn off the animations (to speed up the end result), it would be even more impressive. It would also be helpful if the tool allowed branches and leaves to be created without roots, as they are not always necessary.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: AKS_SpiralGen

AKS_SpiralGen 4.1.0 script by Kilik: http://www.creativecrash.com/maya/downloads/scripts-plugins/modeling/misc/c/aks_spiralgen--2

AKS_SpiralGen is a tool that creates a spiral, either by creating a cylindrical spiral from the UI or optionally taking a NURBS surface and creates a coiling spiral around the surface.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 1209

Functionality: 6.5
The tool has a few options, but it would be really great if the spirals could be created around a few other things (like polygons or other types of curves besides NURBS). I was getting some issues with the Help file crashing if it can't find the help file (although I suspect that this is more of a Maya issue with the "webbrowser" command then the script itself. In a few cases the script gave a few unusual results which is mentioned in the documentation that adjusting the coils and span values might resolve it.

Design: 6
The code base logically splits up some of the functionality into a few functions, and each function is fairly encapsulated in design. The code would benefit from passing parameters instead of grabbing them from the interface, and in some cases the number of variables in a given function becomes quite long. There are a number of places that have a huge number of if statements that makes the control flow a bit difficult to follow.

Style: 4.5
The coding style is mostly consistent but there are a number of places that the spacing is unusual and makes it more difficult to read. The variable names are quite ambiguous with names like "floatField1", "floatField2", "floatField3", "floatField4" and could be a bit more descriptive (in this case something like "startRadiusField", "endRadiusField", "heightField" and "coilsField" would be more descriptive variable names). The switch statement with cases "a" through to "k" are very difficult to understand and are passed in as parameters which makes it even more difficult to follow.

Documentation: 7
The documentation is pretty good for both the install and the use of the tool (although if the help is not at the correct path it will crash Maya as mentioned above). The in code comments could be a bit more helpful (mostly telling the reader to look at the other doc files), but there are a few places that additional comments would be helpful.

Reusability: 4.5
The code is tightly coupled to the UI, and a few of the functions (like the actual creation of the spiral) do not take any parameters, instead grabbing them from the attributes of the UI. This makes it very difficult to reuse or extend parts of the code, and would be much more powerful if it wasn't hardcoded to a specific implementation. The variable names in a number of places are very ambiguous and would be difficult to maintain without more comments or refactoring.

Overall: 5.5
The functionality is something that addresses a very specific need (creating spiral cylinders or from NURBS surfaces). I suppose in the right project this would be a helpful tool, but a few more options would be nice (especially working with non-NURBS surfaces) and a little more information about how to prevent some of the odd results seen would make this tool more powerful.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Crack Me

Crack Me 1.7.5 script by Chase Cooper: http://www.creativecrash.com/maya/downloads/scripts-plugins/character/c/crack-me

Crack Me is a tool is for cutting polygon objects with a plane, by performing a boolean operation with the plane and giving options for the number of divisions. This tool is a quick way of cutting objects in half. The plane has to go all the way through the object, to perform the action and does not have the ability to create a crack in just part of the polygon mesh.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 183

Functionality: 7
The tool does not have a lot of options, but the end result is nice. Unlike the boolean intersection operation, the area that has been cut is filled with geometry, making it a quicker tool to use then manually cutting and applying the geometry. It would be nice if the tool allowed for small cuts in the geometry with the same functionality, but instead causes one part of the geometry to disappear if the plane is not all the way through the object.

Design: 8
The code is tiny yet powerful, the code does a pretty good job of checking for errors, and the code is nicely separated into appropriate functions. The code almost has a complete separation of UI and procedure code, which is nice, but it would be better to see a complete separation. Overall the functions are pretty good at performing a single task, but this could have a lot to do with the size of the code base as well.

Style: 7.5
The code style is pretty consistent and is organized in a logical manner. There are a few places where the commenting is inconsistent between functions, but oddly enough seems consistent within the function itself. The use of whitespace is pretty good, although it too could be a bit more consistent between the functions.

Documentation: 8.5
The in code documentation is pretty good, and since the code base is small it benefits even more from the comments provided. The creative crash site provides more documentation as well, but the links within the code (to the authors personal site) do not have a lot more information about this tool.

Reusability: 9
The code base is the smaller than the size of some of the functions in some of the other code bases I have reviewed. While there are some elements that might require splitting for bug fixes, the code base is logical, compact and powerful.

Overall: 8
The functionality is simple and straight to the point. The feature it gives is a nice result, and likely useful in a number of cases while modelling (especially if the object needs to be cut in two). Overall it would have been nice to see a bit more functionality (to create partial cracks would be pretty cool), and it would also be helpful if the geometry did not disappear when making a mistake, but otherwise provides a nice result for what it does.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Final Toon Shader

Final Toon Shader 3.6 script by nitisara: http://www.creativecrash.com/maya/downloads/scripts-plugins/c/final-toon-shader

Also called MakeToon this script creates an interface to creating a custom toon material node with additional attributes for any later adjustments.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 711

Functionality: 7
The tool gives a number of custom options in creating the material including: type of shader, fill color and level, outline color, thickness and threshold. Outline for colors, depth and outline contrast. The UI is pretty straight forward and easy to use, and gives nice results with additional tweakable attributes. Some functions set the global render parameters of Maya and do not revert them to the original state.

Design: 7
The code makes use a number of global variables and quite a few larger functions. The number of variables used in some of the functions is quite long, but otherwise the code base is fairly logical and straightforward.

Style: 9
Here the code looks to be quite well organized and closely following some consistent standards. The code does include places of commented out sections of code, but otherwise does a good job of keeping maintanable readable code.

Documentation: 6
WARNING: At the time of this writing, the link website in the script points to a malicious url.

I do not believe this is the intention of the author, but still I was not pleased to see it happen. Besides this issue, most of the internal documentation is pretty useful, the code comments are useful, but could use a few more in some areas. The header comments are a mix of information, thanks and a casual (email or letter like) tone.

Reusability: 6.5
The code base is quite small, but is also tightly coupled with the number of global variables passed to almost every function. This tight coupling between functions and globals makes the code more difficult to extend or maintain, and some other areas are tightly coupled with the UI.

Overall: 7.5
The functionality produces a nice result, and gives a number of options in creating the initial material. It would be nice to have a few more options, or useful for adding additional parameters or settings to other materials, but for what it stands, it does give a nice rendered result

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Skinny

Skinny 3.9.0 script by asod: http://www.creativecrash.com/maya/downloads/scripts-plugins/modeling/c/skinny

Skinny is a tool that has a couple quick menus for quickly painting paints on a rigged character (or object). The tool allows grouping of objects into sets to allow them to be painted individually, as well as a number of tools for selecting or organizing mirroring, rotating joints while painting, removing influences, quick brush size options for painting and more.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 2404

Functionality: 7
The tool does not seem to do a lot of error checking, or at least does not seem to guide the user to use the tool correctly. I found that there are a number of error messages, but often were not that helpful to the user (without looking at what was happening in the code). Conceptually the functionality is interesting, but the having the tool guide the user to make correct decisions would certainly help it be more powerful. The ability to turn the functionality on or off in the menu is nice, but some things (such as the fact the creation of the default group name is invalid), could be put in place that help the user use the tool more effectively.

Design: 6.5
The code for the most part breaks up functionality into logical functions, most of them well encapsulated in terms of functionality. There are a of global variables, and complex scriptJobs which complicate the design, but most of that is fairly minimal. There are a number of known bugs listed both in the code and in the help menu, which would be nice to have fixes (or workarounds).

Style: 6
The code style is a little inconsistent, naming conventions for functions seem to change (for both private and public methods), but also the indentation for functions is not very consistent which makes part of it hard to read. Some of the areas such as listing attributes for the UI are consistently spaced, and yet others, such as nested if statements, are not. While it only happens in one place, hardcoding a path to E:/My Pictures/maya to look for textures could be handled in a slightly different way.

Documentation: 7.5
A lot of the code has pretty good documentation about the logic of the function. The inclusion of the help menu and bug list were also nice, but a little more information would be useful. I feel if the code guided the user a little more there need for documentation would not be as important, but as it stands, some additional information about how to use the tool would benefit most users.

Reusability: 6
The code base is not huge, but may still benefit from breaking some of the logic into separate files (perhaps one for the interface and the other for functionality). A little more consistency in the code base would improve the maintainability of the code as well. The code being released with known bugs, is understandable, but still makes updating and expanding more difficult because of these issues.

Overall: 7.5
The functionality is a clever idea, and I believe that once an artist gets a handle on how the tool can be used, they will enjoy the functionality that is has to offer. I feel that with a few additional bug fixes, some more error prevention design (to help guide the user down the correct path), and a little bit of code cleanup, this tool would be a very nice way to handle painting skin weights.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: XTools

XTools 4.1.1 by andrewosiow: https://www.creativecrash.com/maya/downloads/scripts-plugins/polygon/c/x-tools--5

This tool creates an interface of tools of having a number of tools in one area. The buttons overload 20 of the standard interface, and each button has a popup menu that are similar to the tool. This puts a lot of functionality in one place.

Language: MEL & Python
Type: Maya Editor Script
Script Files: 4
Number of lines: 7443 (MEL) + 5046 (Python) = 12489 (Total)

Functionality: 8.5
The functionality leverages a lot of the initial toolset, but does offer a few unique tools as well. The interface is unobtrusive and there is quite a lot of stuff available in the toolbox in a single place. A number of tools are the standard toolset, but there are a few overloaded and custom functions (additional merging and splitting, quick mirroring tools etc.). One thing I found interesting was the use of a .ma file as an installer, which had custom embedded MEL in it to make it easier to install (and possibly more comfortable for people who don't want to run .exe files).

Design: 6.5
The first thing I noticed is the size of the files. Besides a few of the bootstrap shelf scripts, the majority of code is in two files (7346 lines MEL file and a 5046 lines python file). It seems that the XTools underwent a code rewrite from version 3 to version 4, however the monolithic approach of one file for all the functionality is still there. This is a bit unfortunate since with each of the individual tools, each one of them could have had a separate file and reused the common elements. Some of the functions make use of a significant number of both local and global variables (over 25 global variables in one of the functions). Some of the functions are very long, and a number of functions instead of passing parameters, instead grab the values directly from the UI. Some dependency injection and encapsulation would better help the overall design.

Style: 7
The code style is fairly consistent, but would benefit from following more of PEP8 for coding standards. The use of #end tags at the end of the method suggest a VB or Ruby background, which is fine, but just a little unusual in python code. One thing that would help the reader is distinguishing public from protected or private methods, but since the majority of functions start with xt, it is not entirely obvious by looking at them.

Documentation: 9
There is a lot of documentation and sample videos available at: http://www.andrews3dbrain.com/xtooltraining.html. The package comes with a readme, nice .pdf of the toolset and links to videos and extra information. The code has quite a bit of documentation (although would be nicer as docstrings) which helps navigate the code, but it is not uniformly consistent.

Reusability: 6
The code base is large and in a single file, but a number of functions could benefit from reuse. The lack of a lot of parameters or return values means that the code is tightly coupled to the interface and global variables. This code base could benefit from some separate classes to encapsulate some of the functionality (perhaps each of the tools as a separate class) and it would likely simplify and provide a better architecture to the code base (which seems to have just grown over time).

Overall: 8
The functionality is pretty handy, and a lot of elements have been clearly thought about in terms of creating an easy to use interface. The documentation is great and I thought the use of a .ma file as an installer, while unconventional, was also an interesting and clever approach to guarantee installation setup was correct.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: BatchRename

Creative crash site again today with the BatchRename script by Shepherd: https://www.creativecrash.com/maya/downloads/scripts-plugins/c/batchrename

This script allows files to be renamed based on prefix, base name, base number and format. It selects all the files in the directory and renames them based on the order returned from os.listdir()

Language: Python
Type: Maya Editor Script
Script Files: 1
Number of lines: 234

Functionality: 7
The functionality is decent, allowing a number of options for renaming the file, but not a significant amount. One thing I think would be a wortwhile change would be to allow an artist to search for a path, instead of typing it out. This is less error prone, more intuitive, and possibly quicker than typing out the path by hand. It would be nice to see a few options in the naming options, but it will cover a lot of cases with currently.

Design: 6
The main code has a number of duplications, and some of the code is nested quite deeply in loops and if statements (which also have some repeated code). The code does a lot of branching within a single function which makes following the execution path harder to follow with so many branches in a single function.

Style: 5.5
The code style is consistent which is helpful. Outside of the large branching issues I mentioned, the code also has a number of spelling mistakes (both on functions and variables). The code would also benefit from some additional comments and a little more use of spacing between variables and function parameters.

Documentation: 5
Outside of the header, the code does not have any comments in it (besides some commented out code). The header file has a lot of standard stuff, but not a lot of description. The code could benefit from a little bit of documentation, at least in what it is supposed to do.

Reusability: 6
The code base is not very big, but also does not appear to have any reusable functions. Most of the code is tied closely with grabbing the interface values, but more importantly is quite complex in terms of nested scope, which will likely cause a few issues to be aware of.

Overall: 6.5
The functionality does as it advertises, but it would be nicer to have a few additional options. Another very helpful option would be able to choose which files to include in the filter results. The script appears like it would rename everything in a folder, which may have more uses besides render output, but could also be potentially troublesome if used on the wrong directory (another reason to make the selection of the folder an option). Overall, the script does as it advertises, but a number of other tools and scripts can perform a similar task as well.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: PoseLib

Creative crash site again today with the PoseLib script by seith: https://www.creativecrash.com/maya/downloads/scripts-plugins/c/poselib

This script allows keyable attributes to be saved to an XML file and reapplied to the object (or different objects with the same named attributes). The script offers quite a number of options for the creation and management of the pose.

Language: MEL and Python
Type: Maya Editor Script
Script Files: 2
Number of lines: 3194 (MEL) + 678 (Python) = 3872 (Total)

Functionality: 9.5
The functionality is quite extensive and offers a lot of options for creating, renaming, editing, replacing or moving poses. The tool also does a render of the selection allowing the artist to save out logical snapshots of each of the poses (as well as allowing them to choose background and icon colors). Overall quite a lot of functionality packed into this tool.

Design: 6.5
I understand the use of python seems primarily for the use of the XML modules (which MEL does not have), but it is still a little more difficult to read code that is spread over two languages. The MEL script makes quite a lot of uses of global variables, and the python code has some additional flags (for handling the MacGruff user), which complicates the overall design. Some functions make use of a lot of global variables (~20) which can make a function too complex.

Style: 7
The code style in python is for the most part following the standards, although it would benefit from following a few more of the guidelines of PEP8 for naming and commenting. The MEL script is very long, and a number of parts of the code are commented out, which makes the code even longer and complicates reading.

Documentation: 8
The documentation online at: http://seithcg.com/wordpress/?page_id=19 is very thorough and gives a good indication of the available options and functionality available in these scripts. Most of the code has decent comments as well. One thing that would be important to mention is that after placing the scripts, you have to call the python import:

import poseLibModule

Before calling the MEL main function:

poseLib();


Reusability: 6
The code base is fairly large for one MEL file and complex in that it is dealing with two different languages. Some of the MEL code functions are small enough to be reusable, but a lot of the code uses either a lot of global variables or relies on a UI hierarchy to be too reusable.

Overall: 9
The functionality is very thorough and seems to have grown into a mature and useful tool. This is quite a nice feature set in terms of options and flexibility. For those interested in storing poses, this is one of the nicer sets of functionality I have seen. Some of the options (such as the icon color information) are nice features to have and show a dedication to creating a useful tool.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Zoomerate

Creative crash site again today with the Zoomerate script by mooKid: https://www.creativecrash.com/maya/downloads/scripts-plugins/c/zoomerator-mel

This script creates an interface for a camera to track, pan and zoom a camera quickly (in the x, y, or z axis). The interface allows any camera to be selected, and provides an option to reset the camera.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 124

Functionality: 7.5
The functionality does a pretty good job in setting up some quick options on the camera. I tried it with some more complex camera setups (with some additional constrains and locked nodes) and it had some issues with setting those values, but those could be easily fixed if necessary.

Design: 6.5
The code does an alright job with some errors but does not handle some other uses of the script and some additional error checking would be nice. The camera logic and interface are tightly coupled which would have been nicer to see some separation or application of MVC, but otherwise is alright. The code is separated into three main functions which seem well organized.

Style: 8.5
The code style is very appropriate, and the use of indentation and whitespace is handled nicely. The code uses logical names for variables and functions and is quite easy to read and understand.

Documentation: 8
The documentation and inline comments are suitable and help explain part of the code and the usage in a useful way. The code does rely on the user knowing how to source the script properly (since it does not run correctly if invoked directly in the scriptEditor) but still does a decent job of explaining itself.

Reusability: 7.5
The code base is small, but is also tightly coupled to the interface. Separating out the actual camera movement from the interface could help with maintenance, but otherwise is fairly straightforward.

Overall: 7.5
The functionality is quick and easy to use and gives a nice result. While it is not a complex camera system, or a lot of features, what it does provide are some nice additional controls to camera movement to make pans and zooms a bit simpler to work with.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Rivet Button

Creative crash site again today (will get to the cheese factory soonish), today I looked at the Rivet Button script by bazhutkin: https://www.creativecrash.com/maya/downloads/scripts-plugins/c/rivet-button--2

Simple little script that creates a locator which is constrained to two edges on a polygon or one point on a NURBS surfaces.

Language: MEL
Type: Maya Editor Script
Script Files: 2
Number of lines: 149

Functionality: 8
The functionality does exactly what is described. I think it does a pretty good job in setting up a locator that is easy to parent under, but would be nice to have the option of choosing which node to constrain directly instead of creating a locator and parenting underneath it.

Design: 6.5
The code size is small and compact in terms of total size, but outside of the shelf creation, the main function is just a single function. I realize the focus of making the code base small, but it would be more flexible if the single function was broken up into smaller ones that took parameters instead of hardcoded values. The code also has some duplication, which would benefit from breaking out into a separate function. I also think the code has a logical break between the polygon and NURBS functionality which could also use some separation.

Style: 7.5
The code is fairly well organized and whitespace is used to make the code more easily readable. I am not a huge fan of not indenting the code directly after a function declaration, but since it is otherwise consistent I can not say too much about that style choice. The code is small enough that it doesn't need many comments, but a few would be a nice to have.

Documentation: 7.5
The documentation is pretty small, but it doesn't really need to be too complicated. The code does a pretty good job in letting the user know what went wrong, but it still relies on the user to be aware of where to put the code (and image file) and how to invoke it.

Reusability: 8
Calling the base function is trivial, but if it needed to be extended, it would likely benefit from some refactoring. The code base is very small which makes this quite easy to update or change as necessary.

Overall: 7
The functionality is useful and does a pretty good job of doing what it describes. A few extra options (like choosing what is parented), or having some additional offsets available for positioning. Useful quick and easy tool to use for those looking for this specific functionality.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Unity Vancouver Meetup

I went to the Unity Vancouver Meetup last night which was pretty fun, about 25-30 people attended (although I didn't stay too late). It was interesting meeting some people that worked with Unity, and there were a couple students and indie teams that came out to the event: http://www.meetup.com/UnityGames/events/41411882/

I didn't expect to see many/any of the big companies at something like this, but am curious to see what comes out of some of the bigger partnerships. EA signed a multi-year enterprise deal with Unity back in 2010 (google it), but I do not know of any big EA titles that actually used it (although I did work with a developer who's Unity project was scrapped). Only one EA title "Tiger Woods PGA Golf Online", is listed on Unity's game list link I posted previously. Perhaps it is still too early to call, but it will be intersting to see what comes out of from the larger companies (and if you have to install a custom web plugin, you know that it is not 100% Unity).

I look forward to more meetups, and the best thing about something like this, is that it can be inspiring to hear about people pationately talking about game development. I will have to startup one of my projects again soon.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: AbAutoRig

Again with creative crash site today, I looked at the AbAutoRig script by crumbly: https://www.creativecrash.com/maya/downloads/scripts-plugins/character/c/abautorig

This script is another auto rigging tool (a focus of mine for the last little while), and gives a feature set for building a bipedal skeleton. Some of the options include: FK/IK controls with auto align, mirroring tools, scalable stretchy spline joints.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 10469

Functionality: 9
The functionality is quite nice, and I especially like the initial proxy rig creation. This creates a simple skeleton that allows spacing and joint placement to quickly be moved around before the actual skeleton is created. Some of the options for creation like number of fingers was a nice touch, and quick and intuitive to use, and the error messages help guide the user down the correct path. There are a ton of options in the tool menu for things like adding split joints, weighting, and lots more. Overall the tool offers quite a lot of functionality, with additional options to save information to the shelf or nice to haves like resetting the rig to the original position.

Design: 5.5
The first thing I noticed was that the code was all in one very large (10469 lines) long file. File length is certainly also an element of style, but I feel that when a file gets this long there is simply too much going on. It would be much easier to maintain and understand if it was broken up into even three or four logical files (ideally closer to fifteen to twenty different files, since there is so many different options). Aside from the huge length of the file the rest of the design is well organized, the function length is kept to a reasonable length and the code does a pretty good job separating out the logic into appropriate functions. The main function is buried in the middle of the code (line 3321) and shows that navigating around the code to be somewhat confusing.

Style: 8
The code is quite well organized (which helps when it is so large) and looks to follow consistent naming conventions and appropriate variable and function names. The use of whitespace and indentation is well done, and makes the code easier to read. The code makes good use of comments which also helps.

Documentation: 9.5
The documentation and commenting is quite well organized and there are lots of tutorial videos (hours worth) on the website. Overall a nice job on the online documentation, and the videos are very helpful and thorough. Check them out at:
http://www.olivier-ladeuix.com/blog/2010/09/05/abautorig-part-i-pyro-tutorial/
http://www.olivier-ladeuix.com/blog/2010/08/29/abautorig-part-ii-pyro-tutorial/

Reusability: 5.5
The functions themselves could probably be made to be reusable, but the massive size of the script would make it difficult to maintain. Eventually it would get very difficult to do any bug fixes or updates as it is not that easy to navigate the code base and which functions all interact.

Overall: 8.5
The functionality is really what makes this tool useful, I feel that with some moderate refactoring the individual pieces of the code are well written, but it would greatly simplify the code by separating out and encapsulating functionality in separate functions, instead of the slightly monolithic approach.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code fo the Day: AKS_LightRay

More creative crash site today, I looked at the AKS_LightRay script by Kilik: https://www.creativecrash.com/maya/downloads/scripts-plugins/c/aks_lightray--2

This script is a neat little tool for creating light rigs based on existing vertex selection. The built-in option is to use the vertices of a sphere to create a Global Illumination (GI) setup, but could be used on any number of light rigs. The tool uses a ramp or texture for the light color which is a nice feature to create HDR lighting.

Language: MEL
Type: Maya Editor Script
Script Files: 3
Number of lines: 2255

Functionality: 7
The functionality is quick and intuitive to use, and the error messages help guide the user down the correct path. The tool allows the user to create a custom light rig and adjust the ramp and color settings, in a short amount of time. The UI itself however seems to be a little stretched in places making the options hard to read and update. I suspect that since this was written in an older version of Maya certain UI elements may behave differently.

Design: 7
The code is logically separated into different files and for the most part functions. Some of the functions (especially the UI creation) are quite long and would benefit from separation into smaller encapsulated functions. The code does a good job of maintaining the original settings (such as the renderSettings) when performing a task making sure that Maya returns to the previous state. I prefer not to see the use of evals, but when combined with the scriptJob, it is understandable.

Style: 6.5
Some of the spacing and indentation is inconsistent and the indentation of the UI makes it somewhat difficult to understand the structure of the hierarchy. The code has comments which separate out pieces of the UI, but really splitting these into separate functions would make the code a lot easier to read.

Documentation: 8.5
The in code documentation is appropriate, and the package comes with both an install document and a help file which are quite helpful. I found for Maya 2012 the install needed to run aks_lightRay instead of aks_lightray.

Reusability: 6
A few of the functions could be maintainable and reusable, but unfortunately a number of elements (such as the scriptJobs) are tightly coupled with the rest of the naming conventions and structure of the code.

Overall: 7
The functionality is a nice approach to creating a light rig and the results of the ramp and vertex selection for creation are a nice way of creating a light setup quickly. The issues with the UI are a bit of an inconvenience, but I would rather have useful functionality than a pretty UI (and minimal functionality) any day. Interesting in that there are not a lot of tools that seem to work based on vertex selection for creation, and the documentation is rather helpful as well.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: RockGen

More creative crash site today, I looked at the RockGen 2.0 script by Terry Stoeger: https://www.creativecrash.com/maya/downloads/scripts-plugins/modeling/misc/c/rockgen--2

This script is a neat little tool for creating rock formations with a click of a button. The number of rocks, distribution radius, sheer, noise, min and max.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 624

Functionality: 8.5
The UI and options are very nice, and the results are quite impressive. There seems to be a known bug with the stalagmite option (where it fails to execute the boolean operations). The boulder and quartz options are very nice and well worth use of the tool.

Design: 8
The code is logically separated and the functionality is quite self contained within each of the functions. Some of the functions are a little long, but it would be nice to see a bit more separation of some of the generation code would help minimize any duplication. Overall the structure is quite logical and does a pretty good job of separating the UI from the rest of the functionality.

Style: 7
Some of the spacing and indentation is inconsistent spacing and indentation makes some of the code hard to read. The functions would benefit from some separation to make them smaller and better encapsulated.

Documentation: 8.5
The in code documentation is quite well done, and does a good job helping explain the code. The header on the file explains the code in an appropriate manners and overall increases the value of the code.

Reusability: 7
There generator functions are tied to the UI which makes it somewhat difficult to reuse. The overall code base is quite small and powerful which makes it easier to adapt, but otherwise is closely tied to the interface and would require some modification for expansions or fixes.

Overall: 9
The functionality is pretty cool, and while it would be nice to see the stalagmite rocks, the quartz and boulder are really neat and in general is a fun tool to play with. Likely after using this tool, you will never want to model a rock again.

Until next time,
Michael Hubbard
http://michaelhubbard.ca

Code of the Day: Rig-o-matic

More creative crash site today, I looked at the Rig-o-matic script by Jason Baskin: https://www.creativecrash.com/maya/downloads/scripts-plugins/c/filetexturemanager

This script is an autorigging solution for creating bipedal characters. This allows creation of FK, IK setup, automatic naming of joints and creation of controls.

Language: MEL
Type: Maya Editor Script
Script Files: 1
Number of lines: 4741

Functionality: 6.5
The code offers a nice little UI of options for creating and mirror parts of a rig. The functionality works, but I managed to get stuck a few times on the example rig and could not get the legs and back to properly get the appropriate setup the first couple times. The script relies on very specific selections and hiearachy paths, but would benefit a little more from a wizard like setup of forcing the user to do the right thing.

Design: 5.5
The code uses a lot of variables and global variables, which makes a number of functions quite complex. Some of the functions are huge, there are only 29 functions in 4741, the longest being 1186 lines long. When functions get to this size they become very difficult to understand, and become more likely to be candidates of errors.

Style: 6
Inconsistent spacing and indentation makes some of the cod hard to read. The enormous length of some of the functions mean that even with consistent coding style it would be hard to read. The naming conventions and names of variables are appropriate, but when there are so many of them it is difficult to keep track of them all.

Documentation: 9.5
The script does has pretty good comments, and there are a lot of them, but what really stands out is the documentation and tutorial videos: http://www.3dcentral.com/rigomatic/rigomatic.html. The aspect that would help improve is the error messages when using the script.

Reusability: 4.5
There functions are simply too large and all inclusive to really be maintainable or reusable. There are a few smaller functions that might benefit from reuse, but for the most part it is pretty self contained.

Overall: 6
This functionality and documentation make this a nice little script in terms of usability, but it would be nice if it was a little more helpful when the user went astray. The documentation is helpful, but I still found I needed to do some trial and error to get everything to work. The source code is somewhat challenging, but from the comments the author does not want modifications to the script to occur. (The style may have been written it that way so only the author knows what is going on, or would dare attempt any updates or fixes).

Until next time,
Michael Hubbard
http://michaelhubbard.ca