Hands down, the updates are really not about new big features at all, this time. Well, maybe except for Maya 2010, which’ll, for the first time in years, come in one version only, just Maya 2010, no Unlimited or Complete (which was confusing anyways) and will include Toxik (altough called Maya Composite) and MatchMover.

I still haven’t seen any presentations of these new features, but I’m really looking forward to that. Even though I really dislike the idea of having Toxik inside of Maya by default. I never liked that compositor, always felt very “Flame-ish” and therefore “odd” to me, being used to Fusion or Nuke. But still, I’ll save my judgement after I see a demo.

Autodesk also announced a 3ds Max 2010 SP1 release, which is always good, if it wasn’t for “subscribtion customers only”, which is, in my opinion, bullshit!

Then Softimage 2010 with some minor additions and bugfixes. Notably f-curve editor really needed that sweet touch and Scintilla, which I really felt in love with after it was included in 3ds Max, is also a very nice additon.

They’ve also announced digital production Suites, which seem to be a great idea, possibly taken from Adobe, that you’ll be able to buy a bundle of 3ds Max/Maya, Motion Builder, or even 3ds Max/Maya, Motion Builder, Mudbox. If the prices are “reasonable”, I’m sold!

As I’ve said, I’ll wait for tomorrow’s demos to pass my judgement on these new releases, so, stay tuned…

When I first started developing some tools, to speed up and aid our pipeline, in Maya I was furious to find out about Maya’s implemented GUI tools and methods. It was extremely unintuitive, very badly documented (especially regarding examples of the given object etc…) and heavily limiting. What I’d love to have in Maya was something similar to Max’s GUI objects I was used to.

Especially ever since Max 9, where we finally gained access to the beautiful dotNET framework and its objects, classes etc. I was looking for a similar solution. The only problem with dotNET is its platform dependence. As it’s a Microsoft framework it, obviously, only works on Windows. I’ve heard about Mono for Linux, but since I don’t work on Linux and have very limited knowledge of it, I didn’t investigate any further. There are some other options for platform-independent GUI development, like Qt, which I’m yet to go through. It’s definitely worth looking into, but the great advantage of dotNET, on the other hand, is its presence on virtually any Windows machine, which is simply awesome for heavy tools deployment across multiple machines in a studio environment (I can’t imagine making all our artists to install Qt). So, the obvious step was to look for a way to get dotNET run under Maya.

After searching the net, I quickly realized it won’t be such a simple task as with many other tools I’ve ported to Maya in the form of modules for Python. There is IronPython, which runs under its own interpreter, which makes it impossible to implement in Maya (very sad!), but then I bumped into a project, which seems to be lacking a bit of active development, but looked promising: PythonNet.

There’s a little bit of a glitch. There’s no x64 port and, what’s more irritating, the release version I managed to run under Maya only supports dotNET 1.1, which is a real pitty as the tools you’ll be able to create will have slightly limited functionality for more advanced tools development, but nothing that’d cripple the actual usefulness and richness of the platform, only some more advanced and newly added classes or methods won’t be supported.

An example of the dotNET’s listView object used under Maya:

So, all you need is to download the PythonNet 1.0 RC2 for dotNET 1.1 and install CLR.dll and Python.Runtime.dll in Maya’s bin folder. Done. From there on, you’ll be able to import a CLR module (note the upper-case) and access the dotNET objects and namespaces through it. There are also some nice examples of code to get you going.

Another dotNET example of an actual simple tool I developed for automatic Point Cache assignments:

Here, again, Python really excells in these matters. I’m able to develop a fairly complex GUI for my tools and then instance, inherit and mainly overflow the operators of the GUI, so, in the end, I can plot the same GUI for many various functions, which is very useful.

Right now I’m looking into some ways of getting the alpha verision of PythonNet 2.0, which supports dotNET 2.0 objects, to run under Maya in both x86 and x64 modes. If I get it going, I’ll post the way as well as the compiled modules (as I feel it’ll be necessary).

To save you some time, don’t bother trying to connect to the database (db for short) via the standard example:
DogConn=createOLEObject "ADODB.Connection"
DogConn.Open "driver={SQL Server}; server=localhost; database=test"

output:

-- Runtime error: OLEObject method call failed:
Error Message 1: [Microsoft][ODBC SQL Server Driver][DBNETLIB]SQL Server does not exist or access denied.
method: open()

This concrete driver is a Microsoft SQL Server driver, so obviously, this doesn’t make much senese to use this method for connecting to a MySQL database. Since there are numerous ways of setting up the connection via different providers or drivers I was lost. But thankfully , Sun provides its own ODBC connectors for various operating systems, including 64bit versions for Windows. So download the one that fits your OS and after installing it, just check what name the driver has assigned in the Data Sources(ODBC) under Administrative Tools. It should read “MySQL ODBC 5.1 Driver”, which is exactly what you need for successful connecting to a MySQL database. Easily enough, from the comprehensive list of example connection strings found at ConnectionStrings.com I was finally able to write this code:

DogConn=createOLEObject "ADODB.Connection"
DogConn.Open "Driver={MySQL ODBC 5.1 Driver};Server=serverName;Database=dbName;User=userName; Password=password"

Even though it returns “undefined”, don’t be alarmed, this is a good thing. So, now you’re good to go and start fully appretiating the whole database purpose and design!

As for dotNET. It’s much easier (as it’s Microsoft’s next “big thing”) to code for and also you’re less likely to bump into similar problems. Again, download the latest .NET connector from Sun and try executing this snippet in Max 9+:

dotNet.loadAssembly "C:\\Program Files (x86)\\MySQL\\MySQL Connector Net 5.2.2\\Binaries\\.NET 2.0\\MySql.Data.dll"
DBConnection = dotNetObject "MySql.Data.MySqlClient.MySqlConnection"
DBConnection.ConnectionString = "Server=192.168.1.14;Database=test;Uid=root;Pwd=root"
DBConnection.open()

dotNET works in a slightly different way. Instead of loading up a provider or service, it loads up an “assembly”, which is a dll, in this case Sun’s .NET connector, and then allows you to work with its methods. So I first loaded the dll up, then fired the dotNetObject function, then I specified the connection string and finally opened up the connection. Then you’re good to go!

Even simplier is the Python way of things, as usual All you need is a MySQLdb module available at SourceForge.net, install it for your version of Python and then try running this code:

import MySQLdb as db
conn = db.connect("serverName","userName","password","databaseName")

Now you’re ready for some serious querying! It really is this simple and that’s why I’m really loving Python. Anyways, these were just a few examples of how to connect to a MySQL database via ODBC, .NET and Python, which is really all you’ll ever need for connecting to MySQL from 3ds Max, Maya or XSI.

The concrete problem I had to solve was a prop, a motorcycle (an old, steampunk-like machine), that was already baked into individual point cache files. The prop is consisted of around 1000 pieces and baking the 400f animation takes about 1 hour. The problem was that a simplified version of the bike was animated in MotionBuilder, then the secondary animation was taken care of by my rig, which then gets baked and transferred over to Maya for rendering. Unfortunately when facing extreme deadlines, errors tend to happen. One such error happened from the animation side, the bike was offset in its reference node (if you’re familiar with MotionBuilder, you know this isn’t a good thing). The other thing is the point cache baking that drives its offset data from the parent, NOT from the world origin! Well, PointOven does that, but PC2 doesn’t. The final result was that in Max the bike was offset by a certain translation value and to make it even worse, it was slightly rotated. FBX transferred this offset correctly, but point cache data didn’t take the offset into account and calculated the vertex data from the reference position, which acts in the hierarchy as the identity matrix (matrix3 [1,0,0] [0,1,0] [0,0,1] [0,0,0]) = no offset.

A “safe” solution would be to re-cache the whole prop, which would be a waste of time, as I said, it takes around an hour to do, besides in the particular shot we worked on there were five motorcycles and five riders, which is a sh*t-load of data, if you ask me! So, instead of recaching the data, I identified the problem as a simple, stationary, matrix offset in 3ds Max. I wrote a function that coverted and formatted the 3ds Max matrix3 value into Maya matrix4 value and run a single line of code in Maya to offset the root of the prop with all the caches on.

All this took me about 5 minutes to do instead of an hour and something doing it the conventional way – fixing the error in MotionBuilder, replotting the animation, re-caching the meshes and then re-importing the newly created caches in Maya. Of course I fixed the error later, when I had the time, so that next time we don’t have to offset anything, but in a critical time, such a deadline is, this was the best solution I could have came up with. So, I consider my experimental matrix conversion method as proven and I’ll be looking forward to start fully utilizing this method in my future rigs/systems/tools as that’s a very powerful, yet simple way of bridging various 3ds apps together when it comes to animation data transfer.

The matrix in a 3D space has nothing to do with Neo’s hassle with sentinels, no, instead these are extremely useful and helpful vector arrays that make up a position, rotation and a scale of any object in your scene. Recently I’ve been re-inventing the wheel when I needed to write a system that’d allow me to instantly and without any user input transfer objects from Max to Maya and XSI. The reason for matrices in this case lies in the convenience of the whole matrix storing the object’s entire transformation information, which is, essentially, all that you need in order to accurately describe object’s exact position, rotation and scale in a 3D space.

The other reason is that Max is the only software (of these three) that has a differently aligned coordinate system. As opposed to XSI and Maya, Max’s world up direction is the Z axis, while Maya’s and XSI’s (default) world up direction is the Y axis. So, obviously, you cannot assume that when you move a box in Max 25 units along the X, Y and Z and rotate it 25 degrees along the, let’s say, Z axis, you’d get to the very same location and orientation when transferred to Maya or XSI. Not a chance!

So, how do you solve this problem? Well, thankfully, we have the transform matrix! As I said, every single entity in the 3D space (be it whatever, geometry objects, helpers, nulls, groups, vertices etc…) has its own transformation matrix so that it is explicitly given where the object is situated in the 3D space. There are many types of matrices, but the one we’re most interested in are the transform matrices. To cut the crap, a matrix is an array of values. This isn’t the most precise description of what a matrix is, but in a 3D package, the matrices are returned as a special type of an array. Let’s take a look at what you get when you ask Max and Maya for a special kind of a matrix an identity matrix. This is the matrix that describes the world’s coordinate system, it’s position, rotation and scale. This is the very basic matrix that every object, immediately after creation, transforms in it.

When you invoke a matrix3 1 in Max, it returns this value: (matrix3 [1,0,0] [0,1,0] [0,0,1] [0,0,0]) This is the identity matrix in Max. The very same identity matrix in Maya, as far as I know, cannot be created this way (but I’m almost 100% sure I just don’t know about the way yet), however, it can be queried from an object. If you create any object that’s perfectly aligned to the world and you ask for its matrix by invoking (in MEL) xform -q -m `ls -sl`; (assuming you’ve slected the object) you’ll get this: Result: 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 It may not seem so, but these two matrices are equal and, further more, are the very same, the only difference is that Maya returns a 16 double value while Max returns a matrix3 value. The other reason is that Maya’s matrix is a square matrix of order 4-by-4 (4×4), while Max’s matrix is of order 4-by-3 (4×3), the last column is omitted as it’s always the same and has no special meaning for the user. So, how come they’re “the same”? Well, if you look at it this way:

it should be clear that these identity matrices are exactly the same both in Max and Maya. There is one little problem, however. As I stated before, Maya’s and XSI’s default world’s up axis is the Y axis as opposed to Max’s Z axis. So, even though these identity matrices look exactly the same, they cannot be transferred between the packages as they are as that’d produce unwanted object transformation. What I needed for my project was a one-way conversion. I needed to transform Max’s transformation matrix into Maya’s transformation matrix. Thankfully it’s simpler than you might think. Generally, all you need to do is to transform your input transformation matrix into the Maya’s space, which can be done either from within Maya or directly within Max, or even outside in a separate program.

How exactly do you do that? And what is the Maya’s transformation matrix expressed inside Max? First things first. You have to know the Maya’s world transformation matrix relative to Max’s first in order to transform into that space. This can be easily generated in Max as all you have to do is to align a point helper (point helper because it can display it’s local axis tripod), manually, in Max so that it reflect’s Maya’s default Y axis as the world up axis. Then you ask for its transformation property, which will return this interesting value: (matrix3 [1,0,0] [0,0,1] [0,-1,0] [0,0,0]) That’s it! That was the hardest part of the whole problem Now you have Maya’s world transformation matrix inside Max, it can’t get any more exciting than that! Oks, just kidding, it actually does get more exciting than that! Now it’s just a matter of transforming your transformation matrices into this space. How to go about this is simple. Thanks to a quick research on the internet and a few mathematical articles, I came across this formula:
(
    mayaMatrix = (matrix3 [1,0,0] [0,0,1] [0,-1,0] [0,0,0])
    inputMatrix = $foo.transform
    theResultingMatrix = mayaMatrix * inputMatrix * inverse mayaMatrix
)

or, if you read user documentation you come across this handy function:

(
    mayaMatrix = (matrix3 [1,0,0] [0,0,1] [0,-1,0] [0,0,0])
    inputMatrix = $foo.transform
    theResultingMatrix = xFormMat inputMatrix mayaMatrix
)

(note: the local scope of this script is introduced just to make sure we won’t accidentally mess any existing variables up in your current namespace. If you don’t know what I’m talking about, just disregard this comment )

The resulting matrix is an explicit transform matrix in Maya’s world space. It doesn’t get any more exciting than this! So, at the end of the day I wrote a function that’ll also format the matrix3 value in a 16 double value so that Maya understands it and I could start seamlessly transforming objects from Max in Maya (I’ll leave this part to you). It may not seem too useful at first, but think of the possibilities! Besides I needed this conversion system for a much larger project I’m working on at the current studio that hired me. Let me put it this way: in the end, it’ll save us a lot of time, worrying, sleepless nights and company’s money!

Here’s a screenshot proving the concept:

Recommended education:

Matrix (mathematics)
Transformation Matrix
Matrix Math
Paul Neale’s Transform Matrix tutorial
The Matrix: Explained by Bobo

I find myself scripting in Maya more and more often. As I’ve expressed many times already, I really love and appretiate Python’s way of dealing with things, so having this language available in Maya is a blessing. The most beautiful part is when software actually does all the hard and annoying work for you Scripting in Maya using Python hadn’t been designed the way it should be. Unfortunately, Python only serves as a “wrapper” around MEL commands and MEL architecture. Fortunately there are attempts at simplifying Python scripting in Maya, such as PyMEL from Luma Pictures (which is a studio I feel honored to cooperate with on The Nutcracker: The Untold Story), which is a fantastic “plug-in” for any Maya TD! which was, not surprisingly, done solely through Python itself A fantastic demonstration of Python’s power. However, PyMEL isn’t the topic for this short post, maybe later, when I get more familiar with it and gain more experience using it.

The main reason for getting used to working and parsing a lot of string data is, as stated above, because, by default, Python acts as sort of a “wrapper” around Maya’s native MEL language. You’ll be passing tons of string arguments and parameters to Maya’s Python interpreter, so knowing how to deal with long strings is a must. Today I was solving a trivial issue of assigning numerous texture inputs to quite a few tripleShadingSwitch objects for some complex material and shader definition. The whole, manual, procedure would have been very straight forward, but extremely tedious and time consuming. So, as a TD, I was asked to write a little script that’d do the trick with a very limited user input, which basically meant no UI, which is a good thing for a scripter. If you’ve done some UI coding, you know what I’m talking about, especially in connection to Maya

In the end, I dealt with a lot of string variables that were passed throughout the script in Python. It’d have been a pain in the ass doing this sort of thing in MAXScript, as MAXScript isn’t very “string friendly”. I mean, of course there are various string functions available, but they don’t come even close to waht Python has to offer! A single Python module, called “string”, did all and much more I needed. For example, after importing the module, I was able to, very effectively, break a string down based on a keyword argument and separate individual words. While this concrete example is very easily doable in MAXScript, not so easily doable in MEL, there are many other examples that aren’t so easy to do in MAXScript or MEL in comparison to Python. One example for all. Let’s say you have to deal with namespaces. They usually occur in applications like Maya or MotionBuilder which preven users from naming individual objects the same name under the same level in a hierarchy. When you have multiple hierarchies, you may bump into objects with the same name. Maya will return the shortest namespace possible, so instead of returning a “Sphere1″ it’ll return a “myHierarchy|secondLevel|thirdLeve|Sphere1″ if multiple objects with this particular name exist in the scene. So, for whatever reason, what if you need to replace the specific namespace separator with something else? Here’s an example of a very long string of several words separated with a colon (as it’s a common character for identifyingnamespaces) that you want to replace by an underscore character, let’s say for compatibility reasons (say you want to pass this string to Max). Here’s how to do it in Python (including Python in Maya):

from string import *
aVeryLongString = "a:very:very:very:very:long:string:with:namespaces"
aNewString = replace(aVeryLongString,":","_")

the result: a_very_very_very_very_long_string_with_namespaces

Great! Only three lines of code and very little brain usage was actually needed to perform this task How about MAXscript? Well, MAXscript has a function called replace(), the problem is, it expects a string, a start position, a number of characters it should replace and an actual new string that’ll replace the old ones. Certainly usable, but very inconvenient, especially for casual or beginner scripters. How do you go about this limitation? You can’t import a “string” module or anything like that in MAXScript, so you have to write your own, custom, function to do that for you, which would be one of many ways to solve this little issue. For this example, I wrote a custom function that mimics Python’s replace() functino behavior including the number and nature of arguments it requires.

aVeryLongString = "a:very:very:very:very:long:string:with:namespaces"
fn replaceAll str old kwrd =
(
    while findString str old != undefined do
    (
        str = replace str (findString str old) kwrd.count kwrd
    )
    return str
)
replaceAll aVeryLongString ":" "_"

the result: a_very_very_very_very_long_string_with_namespaces

Basic break down: the function takes three arguments, the actual string you want to work with, and old character you want to replace (it supports more than one character) and a new, keyword (kwrd) to replace with. When invoked, it goes through a while loop to search for the old character string and replaces it with the new kwrd character string. After it’s all done it returns the new string.

Even though this took only a few more lines of code, I used two string specific functions and a loop clause all wrapped up in a custom function to do the trick for me. Besides, as I already mentioned, this method is much more complex and hard to code for an inexperienced scripter who just wants to perform a simple character replacement function. These are the tiny little differences that may cause a lot of trouble and headaches when developing really complex and large scripts or, for example, when you have a Junior TD at the studio who should help you out with simpler, smaller tasks and they bump into some similar problem like this one, which it’s as if they weren’t there since you end up doing the work yourself anyways.

I’ve been recently doing quite a lot of R&D on XML, MySQL etc… in conjunction with Max and/or Maya and I constantly bump into obstacles when building the same code I did in Maya through Python, in MAXScript. The problem is, MAXScript is a proprietary language and therefore, you’re stuck with what you have. It’s a great, easy to learn and easy to master language, don’t get me wrong, but if you’re missing some specific features, you’re pretty much doomed. There are some extensions to be found on the net for MAXScript, but usually, they were done by a guy in similar situation you find yourself, but with extensive knowledge of Max’s SDK and C++/C# programming. I, unfortunately, have very limited knowledge of C++/C# programming and therefore I 100% rely on what I can find on the internet.

On the other hand, Python, for example, is an open-source scripting language. Very mature, very popular, ver widely accepted. This leads to a lot of individual, task specific, modules. So, in my case, recently, when I needed to write to or read from a XML file, I simply downloaded a PyXML package, read briefly the documentation, skimmed through some sample code and in a few hours I was able to write my own procedures to derive data from XML files and write them back to another XML. MAXscript doesn’t have any dedicated procedures/functions for such a task, so you either end up writing your own functions for this purpose, which is rather time consuming or you try your luck and try to search the internet for some already finished code, if there’s any. Same deal with the MySQL connection I was dealing with recently. Again, MAXScript doesn’t provide an extensive way of connecting to a database, it has an AODB object, which is quite limiting and a bit outdated nowdays. Thankfully, there seems to be a solution through dotNET objects, but I can’t use this method in Max prior to version 9 (you may not believe it, but I still prefer Max 8 nowdays ).

So, as you can see, languages such as Python are really a smart way to write your tools in and based your pipeline around. Obviously, Python isn’t the only scripting language of this kind, but it’s very popular and widely spread. I also highly recommend it because of its simple syntax, yet robust toolset. A very smart and far-sighted move from Guido van Rossum, kudos!

Interestingly enough, when I started looking into extending my technical skills and knowledge beyond 3ds Max itself at first I got a bit frustrated. The reason was I thought (as probably many other technical artists out there, based on many discussions I read) that I spent years developing some scripting and technical skills to find out they were useless and I’ll have to learn something entirely different in order to stay at the cutting edge and still being competitive. Now while 3ds Max isn’t a factor here, it’s just a platform anyways, I dived into Maya recently and faced a, seemingly, difficult decision: do I go the MEL way or do I learn Python (available in Maya since 8.5)? The decision turned out to be petty simple! I’ll learn both! As I devoured the user reference files, some tutorials and some books, I found out that once you learn one scripting language syntax and logic, picking up any other (similar) language is quite easy.

Well, MEL, out of the three, comparatively, is the most difficult to grasp, not because of the sheer number of functions and attributes, but because the syntax is a bit too complicated (to my tastes) and the integration of MEL in Maya is also a little too restrictive (compared to MAXScript that I’m coming from). Now, the fact that Maya supports Python (too bad Max doesn’t natively support it as well), even though in a bit of a “MEL falvour” is pretty cool and only thanks to this fact I was able to pick up scripting in Maya very, very quickly! So, what’s so special about Python? Python is extremely easy to learn! Let me compare complexity-wise the three: Python < MAXScript < MEL and if I was to compare the three feature-wise: Python > MEL > MAXScript, so the clear winner is Python. Now, I’m primarily a 3ds Max TD, therefore I’m not able to fully appretiate Python’s power and strength from within Max, or am I? Thanks to the ever-so-awesome folks at Blur and their dedication to using 3ds Max in their pipeline, we have something that’s called “blurPython” which is an extension to MAXScript that allows you to call Python functions and modules. This alone takes scripting in Max to a whole new level! Even though you don’t have a direct Python syntax support in Max, you can’t call Max’s functions with Python (sort of, you can do that actually but it hasn’t got much to do with Python itself) you can access Python modules and functions from within Max, which is awesome. Now think about the feature set of Python, the fact that Python has been around for longer than Max itself and that it really is a production proven scripting framework and you’ve got a one hell of a powerful weapon in your TD arsenal! Especially if you’re into building custom pipelines and data sharing!

This article isn’t that much about all the posibilities you can do with Python itself, I’d rather like to compare some features of MEL, MXS (MAXScript) and PY (Python). So, first things first. When I started exploring Maya’s scripting and its logic, I buped several times into my old habbits of code testing, exploring and writing that I carried from Max. Some examples, when developing some code I tend to setup a bunch of testing global variables in order to speed up some UI testing, cut down on number of clicks in order to test out some tools with more complex UI etc… So I started developing some primitive scripts in Maya that were a bit ahead of print "YAY!\n"; :D. Very soon I bumped in MEL’s design “limitation” (it’s not a limitation so to speak, only in my eyes it looks like a limitation, while in fact it’s simply a matter of design), I cannot reassign a different value class to an already declared variable. Let me explain: MXS allows me to do the following: global testVar = "Hello!"; testVar = 10 which means: globally declare a variable called “testVar” and assign it a string value of “Hello!” then try to assign it an integer value of “10″. MEL won’t let you do this, which was to me, as a starting MEL scripter, quite confusing. The problem got more serious and I got frustrated even more when I learned that there was no way of “undeclaring” variables in MEL, so the “testVar” was available all the time during the session (which means until I restarted Maya). So, as recommended, you should always test your code in a local scope in MEL, which means writing your code within two curly braces: { ⟨your code⟩ }

This was quite shocking to me as a MXS scripter that I didn’t have the freedom to reassign variables with different value classes. Further on, the limitation touched all the aspects of the language I was used to, like arrays that can only carry a predefined value class, you can’t mix up integers with strings for example in MEL’s arrays (lists). So I put up with the fact and tried to learn a “different” syntax. I spent about 2 weeks learning MEL intentionally avoiding Python in Maya as, at first, I thought it was some kind of a “second layer” language above MEL that won’t do much difference in Maya. Oh, how wrong I was! Python, in fact, is much more powerful (to my surprise) in Maya than MEL. You can do the same with Python in Maya as you can with MEL, however, you can do much more with Python than you can do with MEL! This is quite interesting and since before MEL I had been looking into Python a bit, I got interested in it even more.

Everybody on the net says how easy, yet powerful, Python really is, I had to prove it to myself and started looking into the syntax and general Python logic. How glad and happy was I when I discovered that you CAN reassign different class values to a single variable (just like in MXS), I can mix up array (list) item classes any way I like (same as MXS), but the real surprise came when I realized that the PY syntax indeed was easy, so easy that I even think that it’s easier than MXS! And MXS really is easy to pick up and code in, believe me.

Ok, let’s take a look at some examples that I discovered which are very important in scripting in general. The globally declared variables in PY and MXS can be reassigned with a different value class! MEL doesn’t support this feature.

Python:
varA, varB, varC = 10, 20, 30
print varA, varB, varC
varA, varB, varC = "It", "just", "works"
print varA, varB, varC

MAXScript:
varA = 10; varB = 20; varC = 30
print varA; print varB; print varC
varA = "It"; varB = "just"; varC = "works"
print varA; print varB; print varC
(notice the difference, Python actually supports multiple variable assignments on a single line in order as opposed to MXS)

MEL:
{
   $varA = 10; $varB = 20; $varC = 30;
   print ($varA+"\n"); print ($varB+"\n"); print ($varC+"\n");
   $varA = "It"; $varB = "just"; $varC = "works";
   print ($varA+"\n"); print ($varB+"\n"); print ($varC+"\n");
}
Notice that MEL won’t let you reassign a different value class to an already created variable! It’ll try to convert the new class input to the one implicitly created. So, the code above will actually result in:

// Warning: $varA = “It”; $varB = “just”; $varC = “works”; //
// Warning: Converting string “It” to an int value of 0. //
// Warning: $varA = “It”; $varB = “just”; $varC = “works”; //
// Warning: Converting string “just” to an int value of 0. //
// Warning: $varA = “It”; $varB = “just”; $varC = “works”; //
// Warning: Converting string “works” to an int value of 0. //
// Result: 0 //

Now, let’s take a look at loops. These are most common in any scripter’s arsenal so you really have to learn how to write these in order to process repetitive tasks!

Python:
for i in range(1, 10, 2):
   print i

MAXscript:
for i = 1 to 10 by 2 do(print i)

MEL:
{
   for ($i = 1; $i < 10; $i+=2)
   {
      print ($i+"\n");
   }
}

(notice that I put the MEL code in a local scope)

The MAXScript syntax in this case is far easier to read than Python and especially then MEL (also notice how many extra characters you have to put in the code in order to achieve the same result)

Another very useful feature is functions (in MEL they're called procedures). I'm yet into learning what all is possible with functions in Python, but what I've learnt so far is quite enough for my needs.

Python:
def sumTheNumbers(num1, num2):
   return num1+num2
sumTheNumbers(10, 20) #call the function with some input numbers of choice
sumTheNumbers("You ", "can!") #notice that Python doesn't actually care what class of variables you throw at it as long as it can perform the required task

MAXScript:
fn sumTheNumbers num1 num2 =
   (
      return num1+num2
   )
sumTheNumbers 10 20 -- call the function with some input numbers of choice
sumTheNumbers "You " "can!" -- notice that MAXScript doesn't actually care what class of variables you throw at it as long as it can perform the required task
(same thing, MAXScript is also "kind" to the user as to letting them assigning different value classes and performs the operations on them, if possible.)

MEL:
{
   proc int sumTheNumbers(int $num1,int $num2)
   {
      return $num1+$num2;
   }
   print(sumTheNumbers(10, 20)+"\n"); // call the function with some input numbers of choice (from within a print() function in order to see the result)
   print(sumTheNumbers("You ", "can't!")+"\n"); // MEL will automatically convert the input classes to integer class, if possible
}
(notice that I just declared an INTEGER procedure that expects two INTEGER values to be passed to it, so, there's no way you could summarize two floats (i.e.: 10.0 and 20.0) or even strings (i.e.: "You " and "can't!") and expect MEL to return float or string values respectively. What MEL will do is it'll convert the incoming value classes to, in this case, integers, if possible, and then performs the required calculations!

So, there you go, these were basic and simplyfied examples of the different languages. The conclusion could be stated as Python being the superior language to MXS and MEL and its syntax being most conformable to MAXScript (or rather the oposite, MAXScript being very conformable o Python, as MAXscript is younger). There are, of course, much, much deeper differences or similarities that wasn't the purpose of this article to bring up. I'm yet to learn Python more deeply myself, so I can't name more concrete, deeper, differences among the languages. However, if you're facing the same problem (which language to learn) coming from 3ds max, I'd recommend both, MEL and Python. I learnt MEL marginally just to get a glimpse of how it works and how it treats user input and then I went to Python for its much cleaner and easier syntax and much wider possibilities.