mel wiki

Measuring circles

Thu, 02 Feb 2012 17:35:31 GMT

Circumference
- Pi (3.14) times Diameter : C = pi * d
Diameter:
- 2 times the Radius : d = 2 * R
- Circumference / pi : C / pi
Radius:
- Half the Diameter : R = d / 2
Area
- Pi times the radius squared : A = pi * r²

Calculate pi

Thu, 02 Feb 2012 17:30:55 GMT

Pi is the ratio of the circumference of a circle to its diameter, approximately 3.14159.
So if you wanted to calculate this yourself:

# Python code:

# diameter is circumference / pi:
diameter = 5.0

# circumference is pi * diameter:
circumference = 15.7079632679

# so:
pi = circumference/diameter
# 3.14159265359

API : Maya Python API 2.0

Tue, 31 Jan 2012 01:01:00 GMT

Starting with Maya 2012 Hotfix 1, enhancements were made to Python scripting with the new 'Maya Python API 2.0'. You can see some high-level notes here. The docs for it don't seem to be online, but you can download a zip of them here:
http://images.autodesk.com/adsk/files/maya-python-api-2-0-docs.zip
The new api modules are found in the maya.api package.
For example, here is the 'old way' to import OpenMaya:

import maya.OpenMaya as om
print type(om.MDagPath())
# <class 'maya.OpenMaya.MDagPath'>

And the new 'api' way:

import maya.api.OpenMaya as om
print type(om.MDagPath())
# <type 'OpenMaya.MDagPath'>

As you can see, the 'old way' typed instances as objects, but the new way types them as physical new types.

I've also noticed that it looks like the api objects are no longer being wrapperd via swig objects: Calls to someSwigObject.disown() that worked in 2010 will fail on 2012 raising a nice exception:

# AttributeError: 'PyCObject' object has no attribute 'disown' #

This isn't necessarily a result of API 2.0, but it does have a coincidence in timing....

It should be noted that as of this authoring the whole API hasn't been ported over: currently only a subset has: This seems questionable for usage... but I'm not too sure on the background of this project yet.

Here are the list of advantages they post:

Array types are full Python sequences, including slice support.
Methods which take Maya array parameters will usually also take native Python sequences, such as arrays and tuples. *Exceptions are made in some case for performance reasons.
The outputs of methods are usually returned in their return values, not through their parameter lists. Exceptions are made in some cases for performance reasons.
Methods which return multiple values (e.g. MFnFluid.getResolution) return them as a tuple or list, eliminating the need for MScriptUtil.
Object attributes are preferred over rather than set/get methods. For example you can now write array.sizeIncrement=64.
There are more types of exceptions used when methods fail. Not everything is a RuntimeError, as was the case in the old API.
The new API is generally faster than the old. Up to three times faster in some cases.

API: Attribute Creation & Usage

Tue, 31 Jan 2012 00:14:00 GMT

Several subjects below, here's what we have:

Overview of API Attribute-Related Concepts
Attribute Property Defaults
Overview of API attribute creation classes
Creation
Example Usage
Differences between 'compound' and 'array'
Understanding Array Indices (physical & logical)
Networked and non-networked plugs
Additional examples

Important note:
In Maya, the term 'attribute' can mean two different things based on where it's used: either the 'user side' or the 'programmer side':

On the user side, they interact with attributes on nodes, querying\setting their values, keyframing them, etc. The only point of entry is "the attribute". The attribute 'has a value', for example. The value and the attribute go hand in hand.
On the programmer side, an 'attribute' is:
- Quoted from 'Complete Maya Programming': "...a template or blueprint for how a piece of data in the node should be created. The important distinction from the user's perspective is that the attribute doesn't actually hold any data. It simply provides a specification for the data. Given this specification, the actual data is created.".
- Basically, it's a description for the type of data that can be stored, but that's only part of the equation (one of four main parts).

The next section describes the four areas that are required for data storage\retrieval on a node in the API.

Overview of API Attribute-Related Concepts:

Attributes:
- Attributes in the API define the name and type of data a node can store.
- Attributes themselves don't store data, they define what type of data can be stored.
- Analogies help: Picture a house as a representation of a node. Each attribute is represented as a gate around the house: Only if a package can 'fit through a certain gate' can it be allowed into the house. Each gate defines access to one type of 'package', but it itself doesn't store the package.
- API attributes differ from user-interaction in Maya on a node. When in Maya you execute "setAttr sphere02.translsateX 3;" it feels like you've set the translateX attribute to the value of 3. But behind the scenes, it's not being stored that way: The translateX attribute is simply the gate through which you've squeezed your numeric package. Where that value actually lives is discussed below.
- They are represented as MObject objects, and created\manipulated (at time of creation) via MFnAttribute and descendant classes.
Plugs:
- A plug is an instance of an attribute on a node.
- They allow you to get and set data, make connections, lock attributes, etc.
- Following the house analogy from above, a plug is like a gate-keeper: It can lock the gate, pass data from outside the gate to inside the gate (and vice-versa), and even connect gates between two different houses together.
- They are represented as MPlug and MPlugArray objects.
- They can be created & queried via MFnDependencyNode (& its descendants), queried via MAnimUtil, are passed as an argument to MPxNode.compute(), and additionally manipulated via MDgModifier.
Data Handles:
- When a node is computing data (in its compute() method) and needs to access data in its data block, it gains that access through a 'data handle'.
- Data handles allow you to query and set data living in a data block, as defined by a given attribute.
- Data handles can't make connections between attributes or lock them (for example), they only query\set data. But because of this they can operate much faster than plugs. In addition, they can query a 'dirty' attribute without forcing a recompute of the DG which can allow for even greater optimization.
- Following the analogy, a data handle is like a butler who can put data in storage (received from the plug), and take data out of storage, passing it to the plug.
- They are represented as MDataHandle and MArrayDataHandle objects. They are created via MDataBlocks.
Data Blocks:
- The data block is the location in the node where the attribute values are stored.
- Whenever a new instance of a node is created, a new data block is created for it.
- Using the house analogy, the data block is the store-room of the house where all the packages are stored. The butler can put stuff in and take it out.
- They are represented as MDataBlock objects, and passed to the MPxNode.compute() method as an argument: That's the only way (I'm aware of) you can access them.

Another way to visualize the analogy:

Plug	Attribute	Data Handle	Data Block
Gate Keeper	The Gate	Butler	Storeroom

Imagine that a node is a house.
The gate keeper (plug) can lock\unlock the gate, let packages (data) pass through the gate to the butler, magically connect this gate to the gate on another house (so that they share packages), or get packages from the butler.
The gate itself (attribute) limits what type of packages are allowed into the house (or what type of package is retrieved from it). If the package doesn't fit, an alarm (error) goes off.
Presuming the package fits through the gate, if the gatekeeper wants the package put in the house (or wants to get a packaged stored in the house), he needs to have the butler (data handle) do it for him.
All packages are kept in the storeroom of the home (data block), which the butler knows a quick path to.
Finally, the gate keeper can have direct access to the storeroom if he's tricky (but he's slower than the butler), and if you slip the butler a $20 (and you sneak in via compute()) you can access the storeroom directly.

So you could say:

A package arrives at the home. Since it fits through the gate, the gatekeeper passes it to the butler. The butler than puts it in the storeroom.

Attribute Property Defaults

When a new attribute is created, these are the default states of its various properties. They are modifiable via MFnAttribute (attribute superclass).

Readable.
Writable.
Connectable.
Storable.
Cached.
Not arrays.
Have indices that matter.
Do not use an array builder.
Not keyable.
Not hidden.
Not used as colors.
Not indeterminant.
Set to disconnect behavior kNothing.

Overview of API attribute creation classes:

All of these inherit from MFnBase

MFnAttribute : Used for changing the attribute defaults listed above (among others).
- MFnCompoundAttribute : For the creation of 'compound' attributes: Attributes that can store multiple different data types.
- MFnEnumAttribute : For the creation of 'enum' attribute types.
- MFnGenericAttribute : Creation of attrs that can accept specific data types as defined by MFnData. Similar but different from MFnTypedAttribute, see docs here
- MFnLightDataAttribute : For the creation of 'light data' attribute types.
- MFnMatrixAttribute : For the creation of 'matrix' attribute types.
- MFnMessageAttribute : For the creation of 'message' attribute types.
- MFnNumricAttribute : For all 'numric' attribute types as defined by MFnNumricData. These include boolean, byte, character, short 2short, 3short, int, 2int, 3int, long, 2long, 3long, float, 2float, 3float, double, 2double, 3double, 4double, and finally 'color' and 'point'.
- MFnTypedAttribute : Creation of attrs that can accept specific data types as defined by MFnData. These include: numeric (based on MFnNumricData), plugin, pluginGeometry, string, matrix, stringArray, doubleArray, intArray, pointArray, vectorArray, componentList, mesh, lattice, nurbsCurve, nurbsSurface, sphere, dynArrayAttrs, dynSweptGeometry, subdSurface, nObject.
- MFnUnitAttribute : For creation of attributes that store angle, distance, and time.

Creation:

Placeholders for the node's attributes are initially added as a class-attribute for easy access later. At this point, then can be filled with MObjects (since that's what they'll be ultimately), or just be filled with None since at this point they're not used.

import maya.OpenMaya as ompx
class Foo(ompx.MPxNode):
    attr_someInput = om.MObject() # or None
    attr_someOutput = om.MObject() # or None

They are actually created and added to the node inside the plugin's 'initializer' classmethod (or external function. We'll use classmethod below). For each attr, they go through one or more of these steps:

Creation : An attribute is created. You can imagine it just floating in space...
Modification : After creation, you configure how it should behave.
Attach to node : Take it from floating in space, and actually attach it to a specific node.
Defining affects relationship : Set if it affects any other attribute. Special note: This step must occur after any affected attributes have already been attached to the node (via MPxNode.addAttribute()).

    @classmethod
    def nodeInitializer(cls):
        # Create the function object that will create the attributes:
        mfnNumericAttribute = om.MFnNumericAttribute()

        # 1. Creation:
        cls.attr_someInput = mfnNumericAttribute.create("someInput", "si", om.MFnNumericData.kFloat)
        # 2. Modification:
        mfnNumericAttribute.setChannelBox(True) # default is False
        mfnNumericAttribute.setKeyable(True)  # default is False
        # 3. Attach to node:
        cls.addAttribute(cls.attr_someInput)

        # 1. Creation:
        cls.attr_someOutput = mfnNumericAttribute.create("someOutput", "so", om.MFnNumericData.kFloat)
        # 2. Modification:
        mfnNumericAttribute.setWritable(False) # Default is True.  This is an output, can't write to it.
        mfnNumericAttribute.setStorable(False) # Default is True.  Do not save value with scene, since it's an output.
        # 3. Attach to node:
        cls.addAttribute(cls.attr_someOutput)

        # 4. Affects relationships for "someInput" attr.  This needs to be executed after
        #     the "someOutput" attr was added to the node.
        cls.attributeAffects(cls.attr_someInput, cls.attr_someOutput)
        # 4. Affects relationships for "someOutput":
        # None, this is an output

Another attribute type to make is a numric type with children. A transforms .translate attribute illustrates this: There is a root 'translate' attribute you can set, connect to, etc. But in addition, you can set\connect to its individual children as well:

translate : float 3
--> translateX : float
--> translateY : float
--> translateZ : float

How can you set this up in the API? You first create each of the child attributes, and then, when creating the parent, you pass them as a creation argument. Here's a simple example snippet:

    @classmethod
    def nodeInitializer(cls):
        mfnNumericAttribute = om.MFnNumericAttribute()

        # Create the children attrs:
        cls.attr_transX = mfnNumericAttribute.create("translateX", "tx", om.MFnNumericData.kFloat)
        cls.attr_transY = mfnNumericAttribute.create("translateY", "ty", om.MFnNumericData.kFloat)
        cls.attr_transZ = mfnNumericAttribute.create("translateZ", "tz", om.MFnNumericData.kFloat)
        # Now create the parent attr by passing in the children:
        cls.attr_trans = mfnNumericAttribute.create("translate", "t", cls.attr_transX, cls.attr_transY, cls.attr_transZ)
        mfnNumericAttribute.setChannelBox(True)
        mfnNumericAttribute.setKeyable(True)
        cls.addAttribute(cls.attr_trans)

Some things to note:

The MFnAttribute docs say "This form of the create method allows the creation of compound attributes out of numeric attributes." So, even though we build using a MFnAttribute, it ends up being MFnCompoundAttribute? (I've yet to figure out what's going on here).
- When making compound attrs, their children all need to be added to to the class via cls.addAttribute(). However, in the examples I've seen, when making 'child array attrs', they don't need to be added that way: only their parent does (like in the above example).
You modify the parents parameters (setChannelBox, etc) not the children, since the children inherit the parameters.
By passing in three kFloat children, it implies that the someInput attr is now a k3float.

If you didn't care about the child attributes, you could simply create the attribute this way:

    @classmethod
    def nodeInitializer(cls):
        mfnNumericAttribute = om.MFnNumericAttribute()

        cls.attr_trans = mfnNumericAttribute.create("translate", "t", om.MFnNumericData.k3Float)
        mfnNumericAttribute.setChannelBox(True) 
        mfnNumericAttribute.setKeyable(True)
        cls.addAttribute(cls.attr_trans)

So you can still manipulate translate as you're used to, but you no longer gain gain access to the children, like translateX.

Example Usage:

The attrs are accessed inside the compute() method. Take note of a few things:

First there is a query if the given input plug is an instance of the attribute that needs computing.
Next, a data handle based on that instanced attribute is generated pointing inside of the data block.
Work is done on the data.
Finally, another data handle is created pointing to the data defined by the instanced output attribute, the output data is updated, and the input plug is set to clean.

    def compute(self, plug, dataBlock):
        """
        This is an overridden method of the MPxNode class.  Does the "work" the node is to perform.

        Parameters:
        plug : MPlug : http://download.autodesk.com/us/maya/2010help/API/class_m_plug.html
        dataBlock : MDataBlock : http://download.autodesk.com/us/maya/2010help/API/class_m_data_block.html
        """
        # Check that the requested recompute is our output value
        if (plug == Foo.attr_someOutput):
            # Read the input values, returns a MDataHandle, which is  a smart pointer
            # back into the MDataBlock (dataBlock)
            # http://download.autodesk.com/us/maya/2010help/API/class_m_data_handle.html
            dataHandle = dataBlock.inputValue(Foo.attr_someInput)

            # Compute the output values.  In this case, it is a simple mult operation:
            outVal = dataHandle.asFloat() * 10

            # Get a handle to the output value and store the new value.
            handle = dataBlock.outputValue(Foo.attr_someOutput)
            handle.setFloat(outVal)

            # From the docs:  Tells the dependency graph that the given attribute
            # has been updated and is now clean. This should be called after the
            # data in the plug has been recalculated from the inputs of the node.
            dataBlock.setClean(plug)
        else:
            # c++ requires this return, it seems that the Python API doesn't
            # based on my experiments.  Doesn't hurt to leave it though.
            return om.MStatus.kUnknownParameter

Differences between 'compound' and 'array'

compound is an *attribute type*, like float, string, double etc. You can't have a "compound float" attribute in the same way you can't have a "string double". But you can have a compound attr that has child string, double, and float attributes. Compound attributes themselves store no values: They are simply parents of other attribute types.
- Compound attributes are considered 'parents', while they contain 'child' attributes.
- The child of a compound attribute can be any other attribute type, including another compound attribute, which has children (which could be compound attributes, etc). Examples of this are the mesh node's colorPerVertex compound attribute. It has a child compound attribute vertexColor, which has a child compound attribute vertexFaceColor.
array (also known as 'multi' when being created via mel, I think...) is a *property of an attribute*, like being readable, writable, keyable, etc. In theory any attribute type can be made array, *including compound attrs*.
- An example of this is a mesh node's uvSet attr: It is a compound attr, but is also an array, which gets confusing fast when trying to access it and its children.
- Array attributes contain multiple 'element attributes', one for each index in the array. These in turn can be any type, including compound, which in turn could also be array, etc.
- Array elements are not 'children attributes', since only compound attrs have official 'children'. Array attributes are a single attr, that holds multiple values in a list.

Understanding Array Indices (physical & logical)

Given an attribute that is also array, you can reference its elements two different ways, via the "physical indices" and the "logical indices".

Physical index : Range from 0 -> numElements()-1. Given four plugs for elements A, B, C, and D, A is index 0, B1, C2, D3. If plug B was deleted, now: A0, C1, D2: As you can see, the physical index for a given plug can change based on creation and deletion.
Logical index : For a given element, this is an assigned\fixed\absolute index that will never change regardless of creation or deletion of other indices. You can use the plugs getExistingArrayAttributeIndices() method to populate a MIntArray with the existing indices.
- Referring to an array element in MEL uses the logical index. MEL can't get the physical index.
- Connections between attributes are based on their *logical indices*. This is needed since the logical indices don't change (and you don't want connections to change after they've been made...).

You can query these indices via MPlug. Below is some example code and results showing the differences between them. When calling to elementByLogicalIndex(), if the given index doesn't yet exist (it is a 'sparse array'), it is created and populated with a default value for that attribute.

plg = myPlg.elementByLogicalIndex(2)
plg.setDouble(11)
plg = myPlg.elementByLogicalIndex(10)
plg.setDouble(27)
plg = myPlg.elementByLogicalIndex(0)
plg.setDouble(100)

This would be the result of the physical \ logical indices:

Physical 0 \ Logical 0  : 100
Physical 1 \ Logical 2  : 11
Physical 2 \ Logical 10 : 27

Networked and non-networked plugs

I'll be honest, I really don't understand the ins and outs of these yet. But some notes:

non-networked plug : user created plugs used to establish new connections to an attr, get or set a value on an attr. When one of these is used, a networked version of the plug is created and added to the dependency node network. A non-networked plug contains an array of array indices that plot the path from the root plug to this plug.
networked plug : Dependency node plugs, can't be explicitely created: only referenced by users. They also describe the 'tree' of plugs indicating connections made to the attributes of the node.

Additional Examples

API: Simple scripted plugin node : A working overview of a bunch of what the above covers.
API: Find all child attributes under a compound attribute
API: Find all attributes & plugs on a node

Why does adding an item to a Maya main menu remove all the items?

Fri, 27 Jan 2012 16:33:00 GMT

Recently I was trying to hijack Maya's main 'File' menu, to add my own items. What I found was, when Maya launches, the menu is empty until you physically open it (click on it), at which point it is populated with the various menuItems. If you try to add your own items to the menu before it's been opened, when you open it, only your item will be shown. This can be shown by this example:

import maya.cmds as mc

fileMenu = 'mainFileMenu'
fileMenuItems = mc.menu(fileMenu, query=True, itemArray=True)
if fileMenuItems:
    for menuItem in fileMenuItems:
        print menuItem
else:
    print "The menu is unpopulated: %s"%fileMenu

If you haven't opened the File menu before running that code, you'll get the print statement.

How to get this working? Thanks to a tip from David Moulder, I've come up with this solution:

import maya.cmds as mc
import maya.mel as mm
    
def addToFileMenu():
    # If Maya is in batch mode, just exit, no point to update a menu:
    if mc.about(batch=True):
        return
    # Get the global mel variable name for the File menu:
    gMainFileMenu = mm.eval('string $temp_string = $gMainFileMenu')
    # If the contents of the file menu don't exist, build them:
    if mc.menu(gMainFileMenu, query=True, numberOfItems=True) == 0:
        mm.eval('buildFileMenu()')

    # Add our menu to the very top:
    mc.menuItem(label="My Awesome Menu", parent=gMainFileMenu, insertAfter='')

After you execute that function, you get an awesome new menu item at the top of Maya's File main menu.

The mel proc buildFileMenu() is found in this script, which is sourced when Maya launches in gui mode:

C:\Program Files\Autodesk\Maya20XX\scripts\startup\FileMenu.mel

Looking in that directory, there are other scripts for the other menus: EditMenu.mel, DisplayMenu.mel, etc, that can be inspected to find the corresponding code needed to build their contents.

Also see:

How can I update Maya's menus with my own entry?

How can I update Maya's menus with my own entry?

Fri, 27 Jan 2012 16:30:00 GMT

Example: Embed a link to this wiki into Maya's Help menu:

menuItem 
    -p $gMainHelpMenu 
    -l "MEL Wiki" -ann "Your Maya Mel Resource on the Web " 
    -ecr false -c "showHelp -a \"http://mayamel.tiddlyspot.com/\"";

All of Maya's main menu's have their names defined in global string arrays.

Also see:

How can I append a custom sub-menu to one of Maya's main menus?

Fri, 27 Jan 2012 16:30:00 GMT

See: Why does adding an item to a Maya main menu remove all the items?

How can I find the names of Maya's main UI menus?

Fri, 27 Jan 2012 01:11:00 GMT

Method A, via Python:

import maya.cmds as mc
menus = mc.window('MayaWindow', query=True, menuArray=True)
# [u'mainFileMenu', u'mainEditMenu', u'mainModifyMenu', u'mainCreateMenu', ...

Method B, via mel:

All of Maya's main menu's are prefixed with $gMain... Here's how to get a list of them all:

string $all[] = `env`;
for($i=0;$i<size($all);$i++)
    {
    if(`match "^\\$gMain" $all[$i]` == "$gMain")
        {
        global string $temp;
        eval("$temp = " + $all[$i]);
        print ($all[$i] + " = " + $temp + "\n");
        }
    }

Also see:

How can I update Maya's menus with my own entry?

How can I query if a scene has unsaved changes?

Thu, 26 Jan 2012 23:23:00 GMT

import maya.cmds as mc
needsSaving = mc.file(query=True, modified=True)

Have yet to find a API call for this: MFileIO (the obvious place for it) doesn't have a similar method.

Instructions For Use

Wed, 25 Jan 2012 17:23:00 GMT

This is a TiddlyWiki. To really get a grasp on how to navigate it, check out their homepage. Quick directions below:

Conceptually, each 'subject' I post in the wiki is put in a 'tiddler' (based on how "Tiddlywiki's" work). The Instructions For Use section you're in now is a 'tiddler'. Welcome is a tiddler. Tiddlers are like individual blog posts. I tag each tiddler with keywords relevant to the subject of said tiddler, and you can see those tags on a small box on the top right of each tiddler. Clicking on a tag will display a list of every other subject with that tag. Subjects (tiddlers) are also categorized on the left menu-bar under larger subject-headings. ALL the tags from every tiddler are in the 'Tags tab', which is on the right most column of the page.

Mainly, you come to the page looking for an answer, and to find it, you search for tags using keywords that may exist in your problem. When you find a tag, click on it, and see the resultant subjects... see if one matches what you're looking for.

SEARCHING FOR DATA:

Browse the "Tags" tab in the right column for mel-ish key-words.
- Inside the Tags tab, major Categories are all in caps, like "ATTRIBUTES".
- When picking a 'Tag' with more than one link, you can either:
  1. 'Open all' the topics in that Tag (meaning, fully expand all the topics listed in the middle of that pop-up menu).
  2. Open a single topic by picking its heading.
  3. Show all the headings in the Tag by picking: Open tag 'tagname'.
Use your web browsers screen-search ability ('Ctrl+F' in both Firefox & Internet Explorer) to find key-words you're after (good if 'Tags' tab is open).
Or start browsing from the Categories section in the left column. This will open each of their major headings in a new tiddler.

If things get too crowded, use the "close all" from the right column to clean up the page. Or, you can use "close others" from an individual tiddler (This block called "Instructions For Use" is a tiddler, for example).

COPYING DATA FROM WIKI, TO MAYA:

The way the text has been entered into this wiki, copying code from the source-boxes should work:

string $source = "source-code in a box";

Other times it's not in a box, but is still safe for copy:

string $source = "source-code not in a box, but still safe to copy";

If you copy any code outside of a box that's 'not safe', Maya may have a hard time with it's formatting and be angered. Weird

How can I make my own 'UV Texture Editor'?

Mon, 23 Jan 2012 21:26:00 GMT

The textureWindow command.
However, the docs say you can only ever have one of these at a time, and the default one exists on Maya startup. So given that, it's probably better to work with the default one than make your own. Based on my tests, I've been unable to get a custom one to work.

How can I create a material and connected shadingEngine?

Fri, 20 Jan 2012 22:53:00 GMT

Simple function to build the material & shading engine, and connect them together.

# Python code
import maya.cmds as mc

def makeMatAndShader(matName, matType):
    material = mc.shadingNode(matType, asShader=True, name=matName)
    # The material will be selected when created:  Need to de-select before
    # Creating our shadingEngine (since it's a set).
    mc.select(clear=True)
    # Nope, can't do it this way, won't shade properly later for some reason:
    # shader = mc.createNode('shadingEngine', name='%sSG'%material)
    # Need to do it this way:
    shader = mc.sets(renderable=True, name='%sSG'%material) 
    # Can use this rather than a call to connectAttr:
    mc.defaultNavigation(connectToExisting=True, source=material, destination=shader)
    return material, shader

matName = 'myPhong'
matType = 'phong'
print makeMatAndShader(matName, matType)

(u'myPhong', u'myPhongSG')

Matrix info

Fri, 20 Jan 2012 19:40:00 GMT

When I first authored this subject I didn't use matrices very often. But I've found the more I learn about them, the more I end up using them...
Also see my other subjects:

Launch help for the root dagNode type node, which has the base matrix attrs:

showHelp -d "Nodes/dagNode.html

Launch help for the transform node (lots of matrix info):

showHelp -d "Nodes/transform.html";

Web:

I made an image describing how 4x4 matrix multiplication works. You can find it on my blog here, or on flickr here
chapter 9 from the book Beginning Game Development with Python and PyGame: From Novice to Professional has a really well described overview.
http://eddieoffermann.com/blog/tag/matrix-multiplication/
http://www.185vfx.com/2003/03/convert-a-3d-point-to-2d-screen-space-in-maya/
Online video lectures from MIT
http://knol.google.com/k/koen-samyn/matrices-for-3d-applications/2lijysgth48w1/3#
Two different blog posts by Andy Nicholas: How to Read a 3×3 Matrix, Rotating Points With a 3×3 Matrix

Quick 4x4 matrix review of an identity matrix (presuming +X is 'left', +Y is 'up', and +Z is 'forward'). To visualize the x, y, and z-axes, use your hand: Hold your right hand in front of you, pointer straight ahead, thumb up, and middle-finger left: Middle-finger = +X-axis, thumb = +Y-axis, pointer = +Z-axis.

The fourth column 'W' is for the most part unused, it is always (0, 0, 0, 1): This is called the 'homogeneous row'. W = A scalar (single, compared to array) value (also known as the 'homogeneous coordinate') used for conversion from Euclidean to Cartesian coordinates. I'm using those terms because I read it somewhere, not because I necessarily understand what they're talking about :-P
The first three rows represent the vectors that point in the x, y, and z directions of the transformation, which represent the axis in 3D space. Effectively the orientation/heading of the 'local axis' of a transform in Maya. They also calculate scale.
The fourth row (w) represents the translation, or point in space when transformed by this matrix. This is the 'homogeneous row':

	X	Y	Z	W	notes

x-axis	1	0	0	0	'left', mag=scaleX
y-axis	0	1	0	0	'up', mag=scaleY
z-axis	0	0	1	0	'forward', mag=scaleZ
(w) translate	0	0	0	1

(remember, the right 'W' column is ignored for what we do in Maya)

translation: Derived from the bottom row.
- translateX, translateY, translateZ = (0 ,0 ,0)
orientation: Vectors that point in the x, y, and z directions of the transformation.
- x-axis : defines the current heading of the 'left' vector = (1, 0, 0)
- y-axis : defines the current heading of the 'up' vector = (0, 1, 0)
- z-axis : defines the current heading of the 'forward' vector = (0, 0, 1)
scale : The magnitude of each x, y, and z-axis defines the scale = (1, 1, 1)
- scaleX = mag(x-axis) = mag(1, 0, 0) = 1.0
- scaleY = mag(y-axis) = mag(0, 1, 0) = 1.0
- scaleZ = mag(z-axis) = mag(0, 0, 1) = 1.0
shear : still working on that one ;)

Some examples, based on that info:

Where individual rotation axis data is stored in the matrix. Meaning, when you perform an Euler rotation on a node on an individual axis, what part of the matrix does it modify? Do you notice that the row and column for the transformed axis (excluding translation operations) aren't modified during the transformation? (since the other axes are transforming around it.)
X-axis rotation:

	X	Y	Z	W

x-axis	1	0	0	0
y-axis	0	1	0	0
z-axis	0	0	1	0
(w) translate	0	0	0	1

Y-axis rotation:

	X	Y	Z	W

x-axis	1	0	0	0
y-axis	0	1	0	0
z-axis	0	0	1	0
(w) translate	0	0	0	1

Z-axis rotation:

	X	Y	Z	W

x-axis	1	0	0	0
y-axis	0	1	0	0
z-axis	0	0	1	0
(w) translate	0	0	0	1

Translate XYZ:

	X	Y	Z	W

x-axis	1	0	0	0
y-axis	0	1	0	0
z-axis	0	0	1	0
(w) translate	0	0	0	1

Identity matrix rotated 45 degrees along the Z axis. Compare this to the above chart that shows where those values will be stored. Note how the z-axis remains the same (0, 0, 1, 0) since it hasn't changed orientation. But both the x-axis and y-axis now have a new heading? (since they were transformed by the z-axis rotation) And notice how all their magnitudes still equals 1.0? Scale remains at (1,1,1).
- Visualize this using the 'left hand rule' described above: Start with your left hand at identity. Imagine there is a point on the tip of each finger corresponding to each identity vector. Now rotate your hand along the z-axis (pointer) clockwise 45 degrees. Your pointer is still pointing the exact same direction (0, 0, 1), but the points defined by your thumb (+y) and middle finger (+x) have moved in space. But they're all still the same distance away from the middle of the transform, so their magnitudes still each equal 1.0.

.707107	-.707107	0	0
.707107	.707107	0	0
0	0	1	0
0	0	0	1

Identity matrix scaled to be half as wide, and twice as high:

scaleX = mag(x-axis) = mag(.5, 0, 0) = .5
scaleY = mag(y-axis) = mag(0, 2, 0) = 2
scaleZ = mag(z-axis) = mag(0, 0, 1) = 1

.5	0	0	0
0	2	0	0
0	0	1	0
0	0	0	1

Maya transformation matrix:
Simple version:

Scale Matrix * Rotate Matrix * Translate Matrix = final matrix

Long version:
matrix = SP *(-1) S * SH * SP * ST * RP *(-1) RA * R * RP * RT * T
* = matrix multiplication, (-1) = matrix inversion

SP = scale pivot point : point around which scales are performed
S = scale : scaling about x, y, z axes
SH = shear : shearing in xy, xz, yx
ST = scale pivot translate : translation introduced to preserve existing scale transformations when moving pivot. This is used to prevent the object from moving when the objects pivot point is not at the origin and a non-unit scale is applied to the object
RP = rotate pivot point : point about which rotations are performed
RA = rotate axis = rotation to orient local rotation space
- AX * AY * AZ
R = rotate = rotation on x, y, z axes.
- RX * RY * RZ (multiplication is defined by rotate order)
RT = rotate (pivot) translate : translation introduced to preserve exisitng rotate transformations when moving pivot. This is used to prevent the object from moving when the objects pivot point is not at the origin and the pivot is moved.
T = translate : translation in x, y, z axes.

Matrix multiplication happens in order, from left to right. It can be thought of exactly like a transform hierarchy, with child nodes on the left, and parental nodes on the right. The matrix to the right will effect the matrix to the left. So in effect, the root of the hierarchy is 'T' (translate), while the leaf-most child would be 'S' (scale). This is why the translation of a node effects where it is rotated and scaled, the rotation of a node effects the orientation of scale but has no effect on translation, and the scale of a node has no effect over rotation or translation.

It's important to note that Maya internally doesn't store its animation data as matrices. It stores them on nodes, as keyframe data (scalar values), expression data, dynamic sim, etc. The matrix is simply a state value that can be queried based on the end result of the incoming anim data for a given transform.

Matrices are multiplied together to get new matrices. For example, if you wanted to assign the position of objectC as the position of objectA + objectB:

matrixC = matrixB * matrixA

So when you think of 'adding' values, convert that to 'multiplying' matrices.
But what if you want to 'subtract' values? For example, you want the position of objectC to be the difference between objectA and objectB? In this case you add (multiply) by the inverseMatrix.

matrixC = matrixB * inverseMatrixA

dagNode node's matrix related attrs (all of these are available through any transform based node):

Local matrix data, relative to the nodes parent:
- .matrix : Local transformation matrix for the dagNode.
- .inverseMatrix : Inverse of matrix attribute. Multiplying by this value will place it at its parent.
Matrix data for the nodes parent:
- .parentMatrix : The parentMatrix instanced attribute represents the world-space transformation matrix for the parents of this dagNode. If the dagNode is a transform node and its inheritTransform attribute is false, then the parentMatrix is identity.
- .parentInverseMatrix : Inverse of parentMatrix instanced attribute. Multiply the parent by this value to return it to origin.
Matrix data relative to the world:
- .worldMatrix : The worldMatrix instanced attribute is the 4x4 transformation matrix that transforms the object to world-space. There is a world-space matrix for each unique path to the object. Eg. 'ball.worldMatrix[0]' identifies the world-space transformation matrix for the first instance of the object 'ball'. Each world-space transformation matrix is the result of post multiplying the 'matrix' attribute by corresponding 'parentMatrix' instanced attribute (i.e. worldMatrix[i] == matrix x parentMatrix[i]). Thus, the worldMatrix is the concatenation of the 'matrix' attribute of all the dagNodes along the path from the node up to the root of the dag hierarchy.
  - Basically: dagNode.worldMatrix = dagNode.matrix * dagNode.parentMatrix
- .worldInverseMatrix : Inverse of worldMatrix instanced attribute. Multiplying by this will place it at the world origin.

transform node's matrix related attrs:

.xformMatrix : Local transformation matrix. From the docs: "Contains the same information as the matrix attribute on dagNode but it is stored in a format that can be interpolated easily.". Personally, I'm not sure what makes it more easy to interpolate.

It should be noted that on all these attrs you can connect to or query their outputs, but they don't allow for input connections or modifications via setAttr.

Notes on getting Matrix attr data:

Some attributes represent transformation matrices. Although these attributes are represented internally as 4x4 matrices, unfortunately, matrix attributes are not returned as MEL 4x4 matrix types. Instead, they are returned as an array of floats where the elements of the matrix are listed in row major order. For instance, "matrix $m[4][4] = `getAttr ball.worldMatrix`;" will not work. To obtain the value of a matrix attribute, you need something like "float $m[16] = `getAttr ball.worldMatrix`;".

These float arrays (for a 4x4 matrix) are indexed like this:

0	1	2	3
4	5	6	7
8	9	10	11
12	13	14	15

xform command:

It should be noted that when querying matrix translation values (index 12, 13, & 14) Maya always returns them as cm values. If your working units are something else, you'll need to convert them!
If the node ever had 'freeze transformations' (makeIdentity) applied to it, it will throw off the worldspace matrix position.

// Copy the worldspace matrix from pCube1 to pCube2:
// Using 'getAttr' on the .worldspaceMatrix, it calculates all
// scale operations based on all parental nodes as well.
// This can cause the target .shear attrs to be effected.
float $m[16] = `getAttr pCube1.worldMatrix`;
xform  -matrix $m[0] $m[1] $m[2] $m[3] 
		$m[4] $m[5] $m[6] $m[7] 
		$m[8] $m[9] $m[10] $m[11] 
		$m[12]$m[13] $m[14] $m[15] pCube2;

// you could optionally use this to get the matrix, via xform:
float $m[16] = `xform -query -matrix pCube1`;
// Which queries the .xformMatrix attr (see above), but this only 
// tracks the local scale values, not any extra parental scale
// values:  .shear attrs are not effected.

Sets/returns the composite transformation matrix. *Note* the matrix is represented by 16 double arguments that are specified in row order.

Matrix Nodes

decomposeMatrix (standard Maya plugin):
- See Mel Wiki notes here
addMatrix
- Add a list of matrices together.
fourByFourMatrix
- This node outputs a 4x4 matrix based on 16 input values. This output matrix attribute can be connected to any attribute that is type "matrix".
holdMatrix
- Cache a matrix.
multMatrix
- Multiply a list of matrices together.
passMatrix
- Multiply a matrix by a constant without caching anything
pointMatrixMult
- The dependency graph node to multiply a point by a matrix.
wtAddMatrix
- Add a weighted list of matrices together.
dagPose
- Created via the dagPose command, used to store matrix data as a pose. Most often used during skinning operations.

Matrix Commands

dagPose
- Used to store and query matrix data in a dagPose node. Most commonly used during skinning operations.
pointMatrixMult (mel script)
- This script returns the multiplication of a point and a matrix as an array of 3 doubles. It is a wrapper around the pointMatrixMult node, which the script actually creates, modifies, gathers the return value, and then deletes.
- Located: C:/Program Files/Autodesk/Maya<version>>/scripts/others/pointMatrixMult.mel
For Python related matrix commands see: Working with matrices with Python

Syntax for authoring an identity transformation matrix:

matrix $m[4][4] = <<1, 0, 0, 0;
                    0, 1, 0, 0;
                    0, 0, 1, 0;
                    0, 0, 0, 1>>;

Printing 4x4 matrix data:

float $goo[] = `getAttr myNode.worldMatrix`;

for($i=1;$i<size($goo)+1;$i++)
	{
	print ($goo[$i-1] + " ");
	if($i%4==0)
		print("\n");
	}
1 0 0 0 
0 1 0 0 
0 0 1 0 
0 0 0 1

Using getAttr on a matrix attr will return back a float array. But when you want to do matrix math, you have to use the matrix variable type. These funtions will convert back and forth between the two:

global proc matrix floatArrayToMatrix(float $m[]){
	if(size($m) != 16)
		error("Please pass in a float array with exactly 16 elements");
	matrix $mat[4][4] = <<$m[0], $m[1], $m[2], $m[3];
					$m[4], $m[5], $m[6], $m[7];
					$m[8], $m[9], $m[10], $m[11];  
					$m[12], $m[13], $m[14], $m[15]>>; 
	return $mat;
	}

global proc float[] matrixToFloatArray(matrix $m){
	float $return[] = {};
	for($row=0; $row<4; $row++){
		for($column=0; $column<4; $column++)
			$return[size($return)] = $m[$row][$column];
		}
	return $return;
	}

Match the worldspaceMatrix of objectB to objectA:

string $source = "pCube1";
string $destination = "pCube2";

float $m[16] = `getAttr ($source+".worldMatrix")`;
xform -worldSpace  -matrix $m[0] $m[1] $m[2] $m[3] 
		$m[4] $m[5] $m[6] $m[7] 
		$m[8] $m[9] $m[10] $m[11] 
		$m[12]$m[13] $m[14] $m[15] $destination;

This will work, no matter what any parental groups have done to the nodes. Sweet.

Another snippet:
Have a destination node match the position of a hierarchy of source nodes. In this scene, "pCube1" is parented to "group1". The below code will match the worldspace matrix of "pCube2" to the postion of "pCube1" by multiplying the local matrices of "group1" and "pCube1" together.

string $sourceParent = "group1";
string $sourceChild= "pCube1";
string $destination = "pCube2";

// query the local matrix of the parent and child
matrix $matrixSP[4][4] = floatArrayToMatrix(`getAttr ($sourceParent+".matrix")`);
matrix $matrixSC[4][4] = floatArrayToMatrix(`getAttr ($sourceChild+".matrix")`);
// Generate our new  destination matrix, order is important!
matrix $dPos[4][4] = $matrixSC * $matrixSP;

float $m[16] = matrixToFloatArray($dPos);

xform -worldSpace  -matrix $m[0] $m[1] $m[2] $m[3] 
		$m[4] $m[5] $m[6] $m[7] 
		$m[8] $m[9] $m[10] $m[11] 
		$m[12]$m[13] $m[14] $m[15] $destination;
// it worked.  Trust me.

Copyright Information

Fri, 20 Jan 2012 19:31:00 GMT

All information on this wiki is under the Apache Licence, v 2.0:

Copyright 2012 Eric Pavey

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

To understand how this licence works see this overview.
But it pretty much means you can use the information on this wiki however you want, but I always appreciate credit where applicable.

Welcome

Thu, 19 Jan 2012 19:32:00 GMT

About mel wiki (go here first)
Instructions For Use (go here second)
Check out the latest updates (go here third. Hit F5 to refresh your cache to see the latest stuff)

Browse \ Search using:

<--- Major Categories (or 'All Subjects') in the Left column
Key-word Tags in the Right column (press Ctrl+f to open your browser's search, makes it very easy) --->

^{Running tiddlywiki v2.4.0}
^{If you find this wiki useful, let the author know :-)}
Copyright Information

SideBarOptions

Wed, 18 Jan 2012 21:52:00 GMT

close all permaview new tiddler save changessave to webdownloadoptions »

API: Find all child attributes under a compound attribute

Fri, 13 Jan 2012 01:07:00 GMT

After much trial and error, I've whipped up the below code to query all the child attributes under a given compound attribute, and print their names \ types.

This was complicated by a variety of factors:

It took me a while to realize that compound attrs can also be array. I hadn't quite grasped the differences between them: Compound is a type, like float or string. Array is a property of an attribute, like keyable, locked, hidden, etc.
I was able to query compound children, but I wasn't understanding how to query an array of compound attrs children. This was further messed up by the fact the MPlug.getExistingArrayAttributeIndices() method will return negative index values, which cause all sorts of problems. Not sure why it does that, but skipping over them solves the problem.
Understanding the differences between logical and physical index arrays. In a nutshell, you want to use logical most of the time...

For more info on those topics, please see this subject: API: Attribute Creation & Usage

In our example we use a polygonal plane with four verts, called pPlane1 (but make reference to its shape node, pPlaneShape1).

import maya.OpenMaya as om

# The node name, and attribute name, to query:
node = "pPlaneShape1" 
attr = "uvSet"

# Get an MObject by string name:
selList = om.MSelectionList()
selList.add(node)
mObject = om.MObject()
selList.getDependNode(0, mObject)

# Attach a function set to the shape and get the plug to start querying:
mFnDependencyNode = om.MFnDependencyNode(mObject)
rootPlug = mFnDependencyNode.findPlug(attr)

# Get all child plugs for our root, presuming it is a compound attr, since they're
# the only type that have 'children':
plugs = [rootPlug]
for plug in plugs:
    # If the type is compound, and it is also set to array:
    if plug.isCompound() and plug.isArray():
        # Find the logical indices of the array:
        logicalIndices = om.MIntArray()
        plug.getExistingArrayAttributeIndices(logicalIndices)
        for i in range(logicalIndices.length()):
            # getExistingArrayAttributeIndices() can return negative index values
            # for some reason, so we need to be sure to *not* deal with those,
            # since obviously bad things would happen....
            if logicalIndices[i] >= 0:
                # Now find the element plug of that index, which is a compound
                # type attribute:
                elementPlug = plug.elementByLogicalIndex(logicalIndices[i])
                # And query the children of that compound attr:
                for j in range(elementPlug.numChildren()):
                    plugs.append(elementPlug.child(j))
    # If it is compound, but not array:
    elif plug.isCompound():
        # Just get the children of that compound attr:
        for i in range(plug.numChildren()):
            plugs.append(plug.child(i))

for plug in plugs:
    attrObj = plug.attribute() # MObject
    print plug.name(), attrObj.apiTypeStr()

Gives us this result:

pPlaneShape1.uvSet kCompoundAttribute
pPlaneShape1.uvSet[0].uvSetName kTypedAttribute
pPlaneShape1.uvSet[0].uvSetPoints kAttribute2Float
pPlaneShape1.uvSet[0].uvSetTweakLocation kTypedAttribute
pPlaneShape1.uvSet[0].uvSetPoints[0].uvSetPointsU kNumericAttribute
pPlaneShape1.uvSet[0].uvSetPoints[0].uvSetPointsV kNumericAttribute
pPlaneShape1.uvSet[0].uvSetPoints[1].uvSetPointsU kNumericAttribute
pPlaneShape1.uvSet[0].uvSetPoints[1].uvSetPointsV kNumericAttribute
pPlaneShape1.uvSet[0].uvSetPoints[2].uvSetPointsU kNumericAttribute
pPlaneShape1.uvSet[0].uvSetPoints[2].uvSetPointsV kNumericAttribute
pPlaneShape1.uvSet[0].uvSetPoints[3].uvSetPointsU kNumericAttribute
pPlaneShape1.uvSet[0].uvSetPoints[3].uvSetPointsV kNumericAttribute

It should be noted that not all attrs are so verbose. For example, if you set this and re-run it:

attr = "pnts"

All it prints is:

pPlaneShape1.pnts kAttribute3Float

Even though we know there is more than one point in the plane. If you grab all the verts and component level, manually move them with the translate manip, and re-run it, it prints:

pPlaneShape1.pnts kAttribute3Float
pPlaneShape1.pnts[0].pntx kFloatLinearAttribute
pPlaneShape1.pnts[0].pnty kFloatLinearAttribute
pPlaneShape1.pnts[0].pntz kFloatLinearAttribute
pPlaneShape1.pnts[1].pntx kFloatLinearAttribute
pPlaneShape1.pnts[1].pnty kFloatLinearAttribute
pPlaneShape1.pnts[1].pntz kFloatLinearAttribute
pPlaneShape1.pnts[2].pntx kFloatLinearAttribute
pPlaneShape1.pnts[2].pnty kFloatLinearAttribute
pPlaneShape1.pnts[2].pntz kFloatLinearAttribute
pPlaneShape1.pnts[3].pntx kFloatLinearAttribute
pPlaneShape1.pnts[3].pnty kFloatLinearAttribute
pPlaneShape1.pnts[3].pntz kFloatLinearAttribute

Which tells me that in some cases, the plugs don't exist until some type of user interaction. Something even crazier I've found: If instead of grabbing all the verts by hand and deleting them, if I instead run the command:

delete -constructionHistory;

On the mesh, the attrs will appear as well. It must be triggering some kind of massive "you are dirty" flag on all the plugs so they suddenly show up.... or something....

I have yet to find a more elegant solution for this :(

Also see:

API: Find all attributes & plugs on a node
How can I get a list of all the child multi-attrs, of a given attr name? (using the command engine, rather than the API)

Control Photoshop from Maya

Thu, 12 Jan 2012 18:07:00 GMT

(This is all based on a Windows system)
First, you need to get some type of com object solution working in Python for Maya:

See my notes here: Getting pywin32 working in Maya

Once you have that package (or something similar) up and running, you can start having Maya talk to Photoshop. Here's a simple example:

# Presuming you have the package installed....
import win32com.client

app = win32com.client.Dispatch("Photoshop.Application") # Application
psdFile = 'c:/temp/myPrettyPic.psd'
document = app.Open(psdFile) # Document

# For each layer in the psd:
for layerSet in document.LayerSets: # LayerSet in LayerSets, which PS calls 'groups'
    print layerSet.Name
    layerSet.Resize(50, 50)
    layerSet.Translate(128,128)

# Some optional fun:
#document.ResizeImage(64, 64)
#document.Save()

How about some docs? The root for all related scripting docs for multiple versions of Photoshop is here:
http://www.adobe.com/devnet/photoshop/scripting.html

I would recomend taking a look at the "VBScript Reference" for your version of Photoshop, compared to the JavaScript or AppleScript: The VB seems to more closely match the Python bindings\syntax.

Scale one vector about another

Thu, 12 Jan 2012 17:24:00 GMT

While writing a scripted plugin node for manipulating UV's, I needed a way to 'scale them'. The below functions work equally well in 2d or 3d (although the examples are in 2d). They're based around the OpenMaya.MVector class.

In this example, 'percent' is a single value, doing a uniform scale on the vector:

# Python code
import maya.OpenMaya as om

def scaleVector(vec, center, percent):
    """
    Scale a given vector around a center-point, by a percent.

    Parameters:
    vec : OpenMaya.MVector : The vector to rotate.
    center : OpenMaya.MVector : The vector to rotate about.
    percent : float : The percent to scale the vector.

    Return: OpenMaya.MVector : The rotated vector.
    """
    offsetA = vec - center # move relative to origin
    scaled = offsetA * percent # scale by the percent about the origin
    reset = scaled + center # offset back to orig position rel to center

    return reset

vec = om.MVector(.25, .5)
center = om.MVector(.5,.5)
percent = .5
scaled = scaleVector(vec, center, percent)
print scaled.x, scaled.y

0.375 0.5 # yes, this is correct :)

In this example, scale is a vector, allowing for xy(z) scaling, or non-uniform scaling.

def scaleVector(vec, center, scale):
    """
    Scale a given vector around a center-point, by another vector.

    Parameters:
    vec : OpenMaya.MVector : The vector to rotate.
    center : OpenMaya.MVector : The vector to rotate about.
    scale : OpenMaya.MVector : The vector defining the xyz scale values.

    Return: OpenMaya.MVector : The rotated vector.
    """
    offsetA = vec - center
    scaled = om.MVector(offsetA.x * scale.x, offsetA.y * scale.y, offsetA.z * scale.z)
    reset = scaled + center

    return reset

vec = om.MVector(.25, .5)
center = om.MVector(.5,.5)
scale = om.MVector(.5,.5)
scaled = scaleVector(vec, center, scale)
print scaled.x, scaled.y

0.375 0.5 # yes, this is correct :)

Rotate one 2d vector around another

Thu, 12 Jan 2012 17:22:00 GMT

While writing a scripted plugin node for manipulating UV's, I needed a way to 'rotate them'. Since this is a 2d transformation, I came up with the below function. It's based around the OpenMaya.MVector class.

# Python code
from math import radians
import maya.OpenMaya as om

def rotateVector(vec, center, angle):
    """
    Rotate a given 2d vector around a center-point, by a number of degrees.

    Parameters:
    vec : OpenMaya.MVector : The vector to rotate.
    center : OpenMaya.MVector : The vector to rotate about.
    angle : float : The angle in degrees (counter-clockwise is positive).

    Return: OpenMaya.MVector : The rotated vector.
    """
    rads = radians(angle) # convert angle to radians
    offsetA = vec - center # move relative to origin
    rotated = offsetA.rotateBy(om.MVector.kZaxis, rads) # Rotate around origin
    reset = rotated + center # offset back to orig position rel to center
    
    return reset

vec = om.MVector(.25, .5)
center = om.MVector(.5, .5)
angle = 90
rotated = rotateVector(vec, center, angle)
print rotated.x, rotated.y

0.5 0.25 # yes, this is correct ;)