Setting up Variant Sets in native Maya data for export to USD

[TechArtistG]

Hi all, is there currently a way to setup Variant Sets in native Maya data that will translate to USD through file export? I know about the old renderLayerMode exporter option and how to setup the scene for that but seems very legacy.

What the current workflow people are using for an artist to setup a variant set?

Thanks!

[wtelford]

Hey TechArtistG,
We haven't extended the variant creation workflows for export yet, so renderLayerMode is still the only functionality that authors variants. Most feedback we have received to date indicates most studios have been post-processing their exports to author variants. We DO want to improve this workflow.

On a slightly related note we did add the ability to set variants through the Outliner when using the proxyShape (not the export workflow you're asking about).

Do you have some workflows in mind for how you would like variant authoring on export to work?

[ahmidou]

hello @wtelford,
Any ETA about this?

[kxl-adsk]

Like @wtelford was mentioning, there isn't a very intuitive mapping between concepts in Maya and Variant Sets in USD. If you know clever ways of doing this, we would be very interested to hear them.

Setting up variants may include other composition arcs, so it clearly not an easy problem. But I tried to explore a simple workflow where you can get things from Maya and push to the USD stage in memory and save once you are done. Here is a very trivial script that illustrates it (without trying to reference or payload anything, everything is authored on the same layer).

import maya.cmds as cmds
import mayaUsd.lib as mayaUsdLib

from pxr import Usd, Sdf

import ufe

#------------------------ UTILS ------------------------#

def createProxyAndStage():
    """
    Create in-memory stage
    """
    cmds.createNode('mayaUsdProxyShape', name='stageShape')

    shapeNode = cmds.ls(sl=True,l=True)[0]
    shapeStage = mayaUsdLib.GetPrim(shapeNode).GetStage()
    
    cmds.select( clear=True )
    cmds.connectAttr('time1.outTime','{}.time'.format(shapeNode))

    return shapeNode,shapeStage

def pushToVariant(srcDagPath, dstSdfPath, dstLayer, dstVariantSetName, dstVariantName):
    srcLayer = Sdf.Layer.CreateAnonymous()
    cmds.select(srcDagPath)
    cmds.mayaUSDExport(f=srcLayer.identifier, sl=True)
    
    dstStage = Usd.Stage.Open(dstLayer)
    dstPrim = dstStage.GetPrimAtPath(dstSdfPath)
    dstVariantSet = dstPrim.GetVariantSets().AddVariantSet(dstVariantSetName)
    dstVariantSet.AddVariant(dstVariantName)
    dstVariantSet.SetVariantSelection(dstVariantName)
    with dstVariantSet.GetVariantEditContext():
        stage = Usd.Stage.Open(srcLayer)
        root = stage.GetPrimAtPath(Sdf.Path.absoluteRootPath)
        for child in root.GetAllChildren():
            dstPrimPathWithVariant = dstPrim.GetPath().AppendVariantSelection(dstVariantSetName, dstVariantName)
            dstPrimPathWithVariant = child.GetPath().ReplacePrefix(Sdf.Path.absoluteRootPath,dstPrimPathWithVariant)
            print(dstPrimPathWithVariant)
            Sdf.CopySpec(srcLayer, child.GetPath(), dstLayer, dstPrimPathWithVariant)

#------------------------- MAIN ------------------------#

# Start clean
cmds.file(f=True, new=True)

# Create the stage to author new prim with variants
proxyShape, stage = createProxyAndStage()
prim = stage.DefinePrim('/My/PrimWithVariants', 'Xform')

# Something to push into the new stage
torusDagPath = cmds.polyTorus()[0]
sphereDagPath = cmds.polySphere()[0]

# Pushing objects from Maya to stage as variants
pushToVariant(torusDagPath, prim.GetPath(), stage.GetRootLayer(), 'modeling', 'torus')
pushToVariant(sphereDagPath, prim.GetPath(), stage.GetRootLayer(), 'modeling', 'sphere')

# Cleanup
cmds.delete(torusDagPath)
cmds.delete(sphereDagPath)

# Exporting the root layer
#stage.GetRootLayer().Export('/dir/simple_variant_workflow.usda')

I wonder if this type of workflow would be something people would like to do?

[Mudoglu]

Any news about a variant editor?

[neilh-adsk]

Nothing concrete, but there are preliminary designs. The main bottle neck is to determine the priority of editing types of composition arcs, like Reference or Payloads etc. I'll see if we can share any newer designs on the topic.

Neil

[richardHaw]

Hello, any updates on this?

[wallworm]

We have spent time thinking on this. Probably the most robust thing we can do is expose variant authoring in the stage (select a prim and add create/edit variant sets by adding references/payload, etc). The problem on the export side is that you need to have a concept in the DCC that maps to variant sets as mentioned previously. We could create simple wrappers for exporting scene objects as an asset with variant sets but it would be very limited to very specific structures. The other viable solution is to use Bifrost USD as it has nodes for generating variants today.

[wallworm]

We are turning some of our attention soon to improved USD Asset Authoring (building proper USD components with variants). As such, we would love to start getting some more feedback from the community on the workflows you are using today (if any) to generate variants.

• What are the things you currently like/dislike about any of the approaches you are using?
• What would you like to see for creating/generating variants?
• What are your ideal workflows?

[sanders3d]

We haven't been able to use Maya with asset building properly due to the limitations of how to add payloads and asset layers.
The convention we are following is

asset.usda ( holds classes and variant sets )
payload.usda ( payload with sublayers of geometry and materials )
geom.usdc ( sublayer in payload.usda )
shade.usdc ( sublayer in payload.usda )

To be able to do this right now in Maya you need two stages. One which is asset and One which is the payload and sublayers.
For the scene graph we are following this
https://github.com/usd-wg/assets/blob/main/docs/asset-structure-guidelines.md

The variant sets are always placed on the root prim of the asset so you can get the extents hint ( bounding box even if its not loaded ). The model file usually contains all variants and we deactive or active the prims needed in each variant set.

But these questions probably needs a new thread to not derail :)

regards
stefan

[voidreamer]

I think fully embracing bifrost for USD is another option, I've been using it for variant authoring.
however bifrost needs quite more features, having a native python node would be very useful for pipelines, and also improve compounds to be something more dynamic like HDAs in Houdini, better versioning, include dynamic parameters and overall improving the API.
This would make USD asset authoring and more USD processes, easier