What's New in API in Maya 2016

OpenMayaRender

UI Draw Manager Enhancements

• The ordering of the calls made through the UI manager interface is now consistent with the ordering used for the legacy default viewport

• Convenience methods have been added to draw large sets of points or lines:
  • points (const MPointArray& points, bool draw2D) for drawing points in 2d or 3d
  • lineList (const MPointArray& points, bool draw2D) for drawing a list of line segments (1 pair of points per segment) in 2d or 3d
  • lineStrip (const MPointArray& points, bool draw2D) for drawing a line strip (connected line segments) in 2d or 3d
  • The uiDrawManager developer kit example has been modified to include the option to draw using these three new interfaces.
• To support the drawing of internally specified icons, the following interfaces have been added:
  • icon( const MString &iconName, float scale ) : This method draws a single icon with the specified name and 3d scale.
  • getIconNames( MStringArray &iconNames ) : This static method allows plug-ins to query the list of available icon names to use with the icon() method.

  The uiDrawManager developer kit example has been modified to include the option to draw an icon per locator, as well as the ability to choose the icon name and scale factor from the Attribute Editor. The icon option appears in the UI Type drop-down list and an Icon Parameters section is available that contains drop-down lists for the Icon and Icon Scale attributes.

  This image shows the drawing of a set of icons, where each icon is a locator created using the uiDrawManager developer kit example.

  

MShaderInstance Enhancements

• Added functions to query the value of an annotation that is associated with a given uniform: MShaderInstance::annotationAsInt(), MShaderInstance::annotationAsFloat() and MShaderInstance::annotationAsString(). These functions take the name of the parameter and the name of the annotation as input.
• Added function MShaderInstance::parameterSemantic() to query the semantic of a given uniform parameter.
• Added function MShaderInstance::parameterDefaultValue() to query the initial value of a uniform. This value can be set in the effects file when initializing a uniform.
• Added function MShaderInstance::resourceName() to retrieve the name of a texture from the effects file. The resource name can be specified in the effects file using the ResourceName annotation.
• Added functions MShaderInstance::uiWidget() and MShaderInstance::uiName() to retrieve the widget type and the UI name of a parameter. These can be specified using the UIWidget and UIName annotations in the effects file.
• Added functions MShaderInstance::techniqueAnnotationAsString(), MShaderInstance::techniqueAnnotationAsInt() and MShaderInstance::techniqueAnnotationAsFloat() to query the current technique annotation value.
• Added functions MShaderInstance::passAnnotationAsString(), MShaderInstance::passAnnotationAsInt() and MShaderInstance::passAnnotationAsFloat() to retrieve pass annotation values.

MShaderManager Enhancements

• Added function MShaderManager::getEffectsTechniques(). This function takes an effects file name as input and returns a list of all techniques that are defined in the effects file.
• MShaderManager::getEffectsFileShader() and MShaderManager::getEffectsTechniques() now accept the use of compiled DX11 FX files (.fxo)

MRenderItem Enhancements

• Added a new MRenderItem::RenderItemType OverrideNonMaterialItem, which corresponds to internal (non material) items for which the default shader effect has been overridden by an MPxShaderOverride
• Added functions MRenderItem::availableShaderParameters(), MRenderItem::getShaderBoolParameter(), MRenderItem::getShaderIntParameter(), MRenderItem::getShaderFloatParameter() and MRenderItem::getShaderFloatArrayParameter(). These functions may be used on OverrideNonMaterialItem to retrieve outstanding shader parameters that this item overrides (such as the default color, the line width and the point size).
• Added function MRenderItem::setShaderFromNode(), which sets the shader instance to a render item by evaluating the shading network of a surface shader node (either standard or custom) in the scene.
• Added function MRenderItem::isShaderFromNode(), which returns true if the shader instance was set by evaluating the shading network of a surface shader node (either standard or custom) in the scene via the MRenderItem::setShaderFromNode() method.
• Added a definition for the callback function MRenderItem::LinkLostCallback, which is triggered when the shader instance assigned by MRenderItem::setShaderFromNode() is no longer valid.

Shader Fragment Enhancements

• XML schema files are now available as part of the install in the ..bin/ShadeFragment folder of the Maya installation.

  v2pFragment.xsd is the XML schema for shading fragments, and can also be found in XML Schema for Shading Fragments.

  vp2FragmentGraph.xsd is the XML schema for fragment graphs, and can be found in XML Schema for Fragment Graphs.

• The XML Schema for Shading Fragments topic has been updated, and the <xs:simpleType name="LanguageType"> section now includes the line <xs:enumeration value="GLSL" />. This line was added because Maya 2016 now supports GLSL fragments.
• The XML Schema for Fragment Graphs topic has been updated, and the <xs:complexType name="ConnectionListType"> section of the schema has an additional line <xs:attribute name="name" type="xs:string" /> added.
• The XML file for fragment graph for phong1 topic provides an example XML file of the fragment graph for a shading network rooted at phong1.
• If a software shader has attributes with names that match the following, and no shader override is specified, then an attempt is made to automatically map these values for display in Viewport 2.0. This feature is provided in addition to the already supported attributes. See XML file for fragment graph for phong1 for more information.
  • translucence: A float attribute type
  • translucenceFocus: A float attribute type
  • translucenceDepth : A float attribute type
  • matteOpacity : A float attribute type
  • mattOpacityMode : A 16, or 32 bit, or enum attribute type

MFrameContext Enhancements

• Added new MFrameContext::getHwFogParameters() method, which allows users to obtain global fog parameters from the frame context. The method returns struct HwFogParams which includes the following information: whether hardware fog is enabled, hardware fog mode, fog start, fog end, fog density, and fog color.

  See also Hardware fog specific semantics and Shader semantics supported by Viewport 2.0.

• Added new DisplayStyle enums MFrameContext::kFlatShaded and MFrameContext::kShadeActiveOnly to MFrameContext, which can be returned by the MFrameContext::getDisplayStyle() function. They correspond to the Flat Shade All and Smooth Shade Selected Items and Flat Shade Selected Items viewport modes.
• Added new LightingMode enums MFrameContext::kNoLighting and MFrameContext::kCustomLights to MFrameContext, which can be returned by the MFrameContext::getLightingMode() function. They refer to the Use No Lights viewport lighting mode, and custom lights that can be used in the Hypershade Material Viewer panel.

MDrawContext Enhancements

• Added new pass semantic for selection: MPassContext::kSelectionPassSemantic. This pass only occurs during Viewport 2.0 selection and for MRenderItem::OverrideNonMaterialItems, so that the MPxShaderOverride can select the proper effect/pass.

MRenderOverride Enhancements

• If an override has defined custom MUserRenderOperations, any previously bound vertex buffers are now unbound before the user operation is invoked. Previously, it was up to the user operation to perform this unbind.

• Previously, when an MRenderOverride does not set override render targets, the targets that were used were of a preset (fixed) format.

  This behavior has been changed to use instead the Viewport 2.0 rendering options for Float Point Render Target and Multisample Anti-aliasing. You can find these settings by selecting Renderer > Viewport 2.0 > to open the Hardware Renderer 2.0 Settings window, and expanding the Anti-aliasing and Floating Point Render Target categories; or, by selecting Render > Render Settings to open the Render Settings window and clicking the Maya Hardware 2.0 tab, then expanding the Anti-aliasing and Floating Point Render Target categories.

  For example, if a floating point format of R32G32B32A32_FLOAT is chosen, then the color render target will attempt to use the same floating point format.

  If a plug-in wishes to use the previous fixed format, than it can define a single color target with format MHWRender::kR8G8B8A8_UNORM, and a single depth target with format MHWRender::D42S8.

• The viewRenderOverrideFrameCache developer kit plug-in has been modified to output floating point EXR images which can be used in conjunction with setting a floating point format to get unclamped color image output.

• Added MSceneRender::kNoLight to MSceneRender::MLightingMode that allows the user to set Use No Lights mode in a scene render override.
• Added MSceneRender::kFlatShaded and MSceneRender::kShadeActiveOnly to MSceneRender::MDisplayMode. MSceneRender::kTextured is now an individual enum that can be used together with MSceneRender::kShaded or MSceneRender::kFlatShaded. These changes allow more control over the display modes the user can set in a scene render override.

  Updated the function viewRenderSceneRender::displayModeOverride() in the viewRenderOverride developer kit example (viewRenderOverrideOperations.cpp) to show the use of kFlatShaded and kShadeActiveOnly.

MRenderOperation Enhancements

• The return type of MRenderOperation::targetOverrideList() has been changed from MRenderTarget** to MRenderTarget* const*. Maya will not change the individual MRenderTarget* pointers in the returned list.

MRenderUtilities Enhancements

• MRenderUtilities::acquireSwatchDrawContext() and MRenderUtilities::acquireUVTextureDrawContext() now take color and depth targets as optional parameters. Passing valid targets also ensures that the correct GL context is made active on GL and core profile Viewport 2.0 devices.
• MRenderUtilities::releaseDrawContext() now takes an optional parameter that releases the draw targets previously used in the acquireSwatchDrawContext() and acquireUVTextureDrawContext() functions mentioned above.

• New MRenderUtilities::renderMaterialViewerGeometry() method has been added that allows swatch rendering to be drawn by leveraging the Viewport 2.0 implementation of the Material Viewer in the Hypershade.

  There are 3 ways to implement swatch rendering using the new API:

  1. Call MRenderUtilities::renderMaterialViewerGeometry() from MPxHardwareShader::renderSwatchImage() and MPxHwShaderNode::renderSwatchImage() with meshSphere as the shape parameter, MRenderUtilities::kPerspectiveCamera as the cameraMode parameter, and MRenderUtilities::kSwatchLight as the lightRig parameter to render a swatch.

     You can also use meshPlane as the shape parameter and kOrthogonalCameraCloseUp as the cameraMode to generate UV editor images from MPxHardwareShader::renderImage() and MPxHwShaderNode::renderImage().

  2. Leave renderSwatchImage() unimplemented.
  3. Return MStatus::kNotImplemented with the implementation of renderSwatchImage().

     In cases 2 and 3, Maya uses this API to render a default swatch.

     The following developer kit example plug-ins have been updated accordingly:

     • Rendering a default swatch: glslShader
     • Explicit calling renderMaterialViewerGeometry(): hwPhongShader, hwColorPerVertexShader, pyHwColorPerVertexShader

MPxSubSceneOverride Enhancements

• Setting of user defined buffers via the MVertexBuffer::resourceHandle() interface has been fixed.
• Added MPxSubSceneOverride::hasUIDrawables(), MPxSubSceneOverride::areUIDrawablesDirty() and MPxSubSceneOverride::addUIDrawables() to draw simple UI shapes such as lines, circles, text, and so forth.
  • If addUIDrawables() is overridden, then hasUIDrawables() must also be overridden to return true.
  • If areUIDrawablesDirty() returns true, then UI drawables are cleared and re-added every refresh. If the method returns false, then UI drawables persist and are preserved until either the DAG object associated with the override is destroyed or the override is deregistered.
  • The UI drawables do not support instancing draw and transform instances.
  • The apiMeshShape developer kit example (apiMeshSubSceneOverride.cpp) demonstrates use of these functions.

MRenderTarget Enhancements

• Static method MRenderTarget::freeRawData() has been added to allow for plug-ins which are compiled in debug mode to safely free the memory allocated by MRenderTarget::rawData().

MTexture Enhancements

• Static method MTexture::freeRawData() has been added to allow for plug-ins which are compiled in debug mode to safely free the memory allocated by MTexture::rawData().

MTextureManager Enhancements

• A new version of MTextureManager::acquireTexture() has been added that acquires a texture from a file on disk.

  MTextureManager::acquireTexture(const MTextureArgments& args) takes the new class MTextureArguments as its input parameter. Using MTextureArguments, you can provide the arguments (such as file path and mip map levels) for the texture that needs to be obtained.

  Essentially, the new MTextureManager::acquireTexture(const MTextureArgments& args) is almost identical to the existing MHWRender::MTextureManager::acquireTexture (const MString & textureName, const MString & contextNodeFullName, int mipmapLevels = 0, bool useExposureControl = true, const MString & layerName = MString(), int alphaChannelIdx = -1) . However, it has added one functionality. It can accept a file texture node that is required if you want to activate texture background loading. You can set the file texture node through the constructor of MTextureArguments or through the method MTextureArguments::setFileTextureNode().

  See the Parallel mode description in the Material Loading Mode documentation in the Display preferences topic of the Maya User Guide for more information.

MPxDrawOverride Enhancements

• The MPxDrawOverride::boundingBox() function has been changed from a pure virtual function to a virtual function, so that users are not required to always provide an override implementation. The default implementation returns a huge bounding box that will never be culled.

MPxShaderOverride Enhancements

The following new method allows plug-in writers to supply a shader to be used in non-textured mode. If this method is not specified, then a fixed grey shader is always used:

• MHWRender::MShaderInstance * MHWRender::MPxShaderOverride::nonTexturedShaderInstance ( bool & monitorNode )
• This MPxShaderOverride::nonTexturedShaderInstance() method returns an override shader instance to be used when drawing in non-textured mode. If NULL is returned, then an internally defined, non-modifiable shader instance is used. Setting the monitorNode parameter on the method to return true indicates that the associated shader node requires monitoring to call back to the override during the update phase.
• See Effect Overrides for more information.
• New function MPxShaderOverride::overridesNonMaterialItems() that allows the shader to replace the default effect for a non material item (that is, wireframe, edge/vertex components, and so forth). This can be useful for shader overrides that have displacement.

MVertexBuffer and MIndexBuffer Enhancements

• MVertexBuffer::resourceHandle() and MIndexBuffer::resourceHandle() are now supported in DirectX11 mode in Viewport 2.0
• The SubSceneOverride version of the apiMeshShape developer kit example has been updated to demonstrate use of these methods.

  You can test the SubSceneOverride version of the plug-in by following these steps:

  1. In line 2289 of apiMeshShape.cpp, set sUseSubSceneOverride to true
  2. Re-compile the plug-in.
  3. Start Maya in DirectX 11 mode in Viewport 2.0. (Select this option in the Display section of the Preferences window). Ensure that apiMeshShape.mll is located within the folders specified in the MAYA_PLUG_IN_PATH environment variable.
  4. Run following MEL commands

     loadPlugin apiMeshShape;
     createNode apiMesh;
     createNode apiMeshCreator;
     connectAttr apiMeshCreator1.outputSurface apiMesh1.inputSurface ;
     sets -edit -forceElement initialShadingGroup |transform1|apiMesh1;

  5. Switch Viewport 2.0 to bounding box mode, and you will see that the bounding box displays correctly.

Component selection

MPxGeometryOverride Enhancements

• The MPxGeometryOverride::refineSelectionPath() and MPxGeometryOverride::updateSelectionGranularity() functions have been added to support component selection in Viewport 2.0.

MDrawRegistry Enhancements

• The MDrawRegistry::registerComponentConverter() and MDrawRegistry::deregisterComponentConverter() functions have been added to support component selection in Viewport 2.0

MPxSubSceneOverride Enhancements

• Added MPxSubSceneOverride::updateSelectionGranularity() for component selection in Viewport 2.0

New classes: MSelectionContext, MIntersection, MSelectionInfo and MPxComponentConverter were added to support component selection in Viewport 2.0.

Utilities Enhancements

• Several methods have been added to MRenderUtil for accessing the constant noise lookup table that Maya uses to compute many built in procedural textures (for example, Noise, Fractal, Volume Noise, Solid Fractal, and so forth).

• MGeometryUtilities::acquireReferenceGeometry() has been fixed so that when MGeometryUtilities::releaseReferenceGeometry() is called, the memory will be properly freed.

Manipulators Enhancements

• Added a new variation of the MUIDrawManager::beginDrawable() method: beginDrawable(unsigned int name, bool nameIsPickable) which allows manipulator picking in a manner similar to MPxManipulatorNode::colorAndName().

• Added new method MPxManipulatorNode::shouldDrawHandleAsSelected() which queries if a manipulator handle should be drawn as selected/highlighted in Viewport 2.0.

Varying parameters Enhancements

• Added new colorset semantic to shading node override fragment. A 4-float colorset varying parameter represents the vertex color. It is identical to the semantic fcolor, except that multiple colorset varying parameters are supported. See Shading Node Overrides.

Implement a 3rd party renderer in the Hypershade

• Added new class MPxRenderer that allows plug-ins to implement a 3rd party renderer for rendering in the Material Viewer in the Hypershade.

Renderer Enhancements

Color management enhancements

• Added function MShaderInstance::createShaderInstanceWithColorManagementFragment() to create a new shader instance with a color management fragment added.

Shader semantics supported by Viewport 2.0

The list of Semantics supported by Viewport 2.0 has been updated.

Developer Kit examples

• Python API 2.0 developer kit examples can be found in the plug-ins\scripted folder. Each shares the same name as its C++ counterpart, but with a py prefix.

• A new viewObjectSetOverride developer kit example has been added, and a description of the example is provided in Multiple Pass Scene Rendering.

• A new plug-in onbShader has been added to the developer kit that creates a dependency node as a surface shader called onbShader in Maya.

  In addition to implementing the dependency node, this plug-in also shows a complete implementation of a surface shader for Viewport 2.0.

  It demonstrates how to define and register shading fragments and create a final fragment graph.

  This example differs from the lambertShader/phongShader examples in that it does not re-use Maya's built-in fragments, but instead define its own via the plug-in.

• A new plug-in simpleNoiseShader has been added to the developer kit that creates a dependency node as a texture shader called simpleNoise, that implements the Maya wave noise texture type.

  In addition to implementing the dependency node, this plug-in also shows a complete implementation of a texture shader for Viewport 2.0.

  It demonstrates how to define and register shading fragments to create a final fragment graph and associate it with the dependency node. In addition, this example also demonstrates how to create and access the noise lookup table that Maya uses for computing procedural textures.

  The primary shading fragment defines a texture and sampler parameter pair for the noise lookup table. The noise lookup table is then used to build a 3d texture that the pixel shader can sample to compute the final ‘wave’ noise result. New MRenderUtil methods: noiseTableSize() and valueInNoiseTable() are used to access the noise lookup table values. See the simpleNoiseShader developer kit example for more information.

• The footPrintNode developer kit example is now made simpler and demonstrates how to use MUIDrawManager to draw a simple locator in Viewport 2.0.

  Plug-in code using MUIDrawManager offers the following advantages:

  • It works with Viewport 2.0 based selection that is new for Maya 2016
  • It can be written once and used on all platforms and all draw API’s, including OpenGL core profile

  The original sample is now renamed to rawfootPrintNode which demonstrates how to draw the locator with raw OpenGL/DX calls.

  The rawfootPrintNode example has been updated to show how an M3dView can be obtained using the method MFrameContext::renderingDestination() to find the destination name, and then how M3dView::getM3dViewFromModelPanel() can be used to obtain a corresponding M3dView for a panel with the given destination name.

• A new plug-in footPrintNode_GeometryOverride has been added that implements a locator using an MPxGeometryOverride to obtain good draw performance when a large number of locators needs to be displayed at the same time. A Python version is also available.

• The blast2Cmd developer kit example is a new plug-in that performs video capture. It sets and overrides the output target size as well as attaches a renderer notification callback. The callback is called for each frame that the command wants to output. It uses existing interfaces to copy the render target back to a texture, and uses the built in texture saving functionality to save to disk. If the render target is fixed point, the plug-in will store the image in IFF format. Otherwise, if it is floating point, the plug-in will store it in EXR format.

  The following roughly outlines the logic used in this example:

  1. Call MRenderer::addNotification() to add in a post render callback.
  2. Call MRenderer::setOutputTargetOverrideSize() to set an override for the output target size.
  3. Queue a refresh. A render occurs to a target of the override size.
  4. The callback reads back the contents of the output target.
  5. Call MRenderer::unsetOutputTargetOverrideSize() to unset the override for the output target size.
  6. Call MRenderer::removeNotification() to remove the callback.

• The vp2BlinnShader is a simplified example of using an MPxShaderOverride. The plug-in shows the usage of the basic interfaces for this type of override. The example uses an MShaderInstance, which is retrieved by asking the shader manager (MShaderManager) for a stock Blinn shader. As such, the geometry requirements for the shader can be retrieved from the shader instance itself. It does not require an extra DX11 shader signature in this case. The internal method for drawing is also used. There is no additional light handling required as the stock shader has its light bindings automatically updated. The plug-in can run on all platforms and all currently supported drawing APIs (OpenGL, OpenGL Core Profile, DX11), as the implementations are internally provided. Therefore, no additional shading code is required.
• The apiMeshShape plug-in (and its Python version pyApiMeshShape.py) were updated to perform component selection in Viewport 2.0 using an MPxGeometryOverride and an MPxSubSceneOverride. They were also updated to properly manage duplicate and unknown streams, allowing it to work with effects that request multiple UV streams, or ask for binormals and bitangents.

  The SubSceneOverride version was updated to demonstrate support for DirectX11 mode. See the MVertexBuffer and MIndexBuffer Enhancements section above on this page for more information.

• The brickShader plug-in (both C++ and Python versions) has been updated to support GLSL and therefore to run in OpenGL Core Profile mode in the Maya viewport. The shader fragment for GLSL was written based on the HLSL implementation.
• The viewOverrideSimple sample plug-in has been added that demonstrates how to use MRenderOverride, and is a simple example targeted towards beginners. It creates a render override that is listed as a renderer in the viewport menu, and it draws the scene and the HUD, and performs a background color override. The logic used in the sample to create the render override roughly matches that used in Maya’s internal render pipeline.

• In order to compile the DX11 Shader plug-in provided in the developer kit using Visual Studio 2012, you must first compile the Microsoft DirectX SDK Effects11 library using the Visual Studio 2012 project file (Effects11_vs2012.vcxproj) provided in the devkit/plug-ins/dx11Shader folder by doing the following:

  1. Copy the file to the Effects11 folder (in most cases: C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)\Samples\C++\Effects11).
  2. Load the Effects11_vs2012.vcxproj project file and compile the solution from the Effects11 folder.

Documentation updates

• Sections Manipulators and Tool Contexts have been added to the Maya Viewport 2.0 API Guide to provide information on the interfaces used for drawing manipulators and for tool contexts in Viewport 2.0.

• Frame and draw contexts topic added.

• Convert light information from world to view space for fixed function lighting section added.
• Multiple pass scene rendering section added.

OpenMaya

• Added new MEvaluationManager class that allows you to query Evaluation Manager states. The simpleEvaluationNode developer kit example demonstrates its use.
• Added new preEvaluation() and postEvaluation() virtual methods to MPxNode
• Added new MEvaluationNode class to provide access to the set of attributes and plugs that will be set dirty prior to evaluation by the Evaluation Manager.
• Added new MEvaluationNodeIterator class that is used by MPxNode::preEvaluation() and MPxNode::postEvaluation() for support of threaded evaluation. This class is used to easily iterate over the set of attributes and plugs that will be set dirty prior to evaluation by the Evaluation Manager on a given MEvaluationNode.
• Added developer kit example simpleEvaluationNode that shows use of preEvaluation() function
• Added developer kit example simpleEvaluationDraw that shows use of postEvaluation() function

• Plug-ins can now provide hints to the evaluation manager as to how they should be scheduled.

  Scheduling of python plug-ins is now improved. Previously, Python nodes were run in parallel which could cause issues with lock contention, slowing down evaluation.

  Python plug-ins are now globally serialized, avoiding issues with the GIL (global interpreter lock), and improving overall performance.

  To provide scheduling of plug-in nodes, the following new enum and virtual method have been added to MPxNode. They are as follows:

  • ::SchedulingType
  • Users can override the MPxNode::schedulingType() const function, which returns the desired scheduling type for the node.

Added the following new classes to support GPU override deformers:

• MOpenCLInfo
• MAutoCLEvent
• MAutoCLKernel
• MAutoCLMem

• Added new MFnMatrixArrayData class that allows your plug-ins to use MMatrixArray attribute types. This can be used to generate more compact graphs instead of creating multis of MMatrix types. One immediate use of this type is to read cached frame information computed by the new DeltaMush deformer.

OpenMayaAnim

Added the following new classes to support GPU override deformers:

• MPxGPUDeformer
• MGPUDeformerRegistry
• MGPUDeformerRegistrationInfo

Deformer classes have been re-organized. New classes:

• MPxGeometryFilter - the new base class for deformers. This is equivalent to MPxDeformerNode (which still exists), but without per-vertex weight lists.
• MPxSkinCluster - extends MPxGeometryFilter with per-vertex skin weights. Custom nodes derived from this class are treated like the built-in skinCluster in the Maya UI.
• MPxBlendShape - extends MPxGeometryFilter with the input target. Custom nodes derived from this class are treated like the built-in blendShape in the Maya UI.

OpenMayaUI

• A new MGraphEditorInfo class has been added that allows you to query, for a given Graph Editor, UI information such as viewport bounds and animation curve nodes based on its current state.

Developer Kit examples

• identityNode: This example illustrates a simple possible deformer that copies inputs to outputs. It also provides a boilerplate that allows you get started on creating your own deformer.
• offsetNode: This example provides the CPU and GPU implementation of a non-trivial deformer.
• basicBlendShape: This example illustrates creating a basic deformer by inheriting from MPxBlendShape.
• basicSkinCluster: This example illustrates creating a basic deformer by inheriting from MPxSkinCluster.

OpenMaya

MPolyMessage enhancements:

• Added new MPolyMessage::addUVSetChangedCallback() method to register callbacks for UV set modification messages, including notifications for adding and deleting of a UV set, as well as the switching of the current UV set.

MFnMesh enhancements

• Added a method MFnMesh::setPinUVs() to set the specified UVs of the mesh as pinned UVs. A pinned UV is one which should not be modified. If the pin weight is set to 1.0, then it becomes fully pinned and UV tools should not modify that UV. If the pin weight is set to a value between 0.0 and 1.0, then UV tools should weigh their changes to that pin weight accordingly.

• Added a method MFnMesh::getPinUVs() to get the pinned UVs of the mesh, as well as the pin weights associated with those UVs.

• Added thickness and offset options to the MFnMesh::extrudeFaces() and MFnMesh::extrudeEdges() functions. These parameters map directly to the attributes on the extrude face and edge nodes.

OpenMayaUI

New context proxy class

• Added new MPxTexContext context proxy class. This context proxy class provides a way to extend the function of the UV Texture Editor with user defined tools. Several functions for handling interactive events such as: mouse move, mouse press, mouse drag and mouse release are provided. You can override these functions to define the behavior of the new interactive tools for the UV Texture Editor.
• Added new Qt sample plug-in grabUV.pro, which demonstrates how to use MPxTexContext to implement a UV grab brush.

New command proxy class

• Added new MPxPolyTweakUVInteractiveCommand command proxy class. This tool command proxy class provides a simplified way to interactively edit UVs on polygonal objects within interactive contexts. A user can provide new UVs during an interactive command, and by finalizing the editing, all interactive updates are recorded as a single command, and can be undone together.

MPxContext Enhancements

• Added new MPxContext::drawFeedback() method to draw primitives using MUIDrawManager in Viewport 2.0 when the context tool is activated. This is useful for rendering context feedback, such as a brush ring.

Universally Unique Identifiers (UUID's) for nodes

• Added a new class MUuid that is used with MFnDependencyNode when handling UUID's.
• Added a new API callback MDGMessage::addNodeChangeUuidCheckCallback() that allows users to modify the import/reference UUID policy.
• Added a new method to MSelectionList, MSelectionList::add( const MUuid & uuid, bool mergeWithExisting = false ), that adds a node matching the UUID to the selection list.

Python equivalent to MDGModifier::commandToExecute() added

A new MDGModifier::pythonCommandToExecute() has been added that allows you to add an operation that executes a Python command/script to a dependency graph modifier.

This is the Python equivalent of the method MDGModifier::commandToExecute().