def initializer(): # A render layer is a render setup list element. # inheritAttributesFrom() must be called before adding any other # attributes. RenderLayer.inheritAttributesFrom(nodeList.ListItem.kTypeName) # A render layer is a list of collections. RenderLayer.collections = RenderLayer.initListItems() RenderLayer.collectionLowest = utils.createDstMsgAttr( 'collectionLowest', 'cl') RenderLayer.addAttribute(RenderLayer.collectionLowest) RenderLayer.collectionHighest = utils.createDstMsgAttr( 'collectionHighest', 'ch') RenderLayer.addAttribute(RenderLayer.collectionHighest) RenderLayer.legacyRenderLayer = utils.createDstMsgAttr( 'legacyRenderLayer', 'lrl') RenderLayer.addAttribute(RenderLayer.legacyRenderLayer) # Add isolateSelected attribute RenderLayer.numIsolatedChildren = enabled.createNumIsolatedChildrenAttribute() RenderLayer.addAttribute(RenderLayer.numIsolatedChildren)
def initializer(): ListItem.parentList = utils.createDstMsgAttr('parentList', 'pls') ListItem.addAttribute(ListItem.parentList) ListItem.next = utils.createSrcMsgAttr('next', 'nxt') ListItem.addAttribute(ListItem.next) ListItem.previous = utils.createDstMsgAttr('previous', 'prv') ListItem.addAttribute(ListItem.previous)
def initializer(): # A render setup is a list of render layers. RenderSetup.renderLayers = RenderSetup.initListItems() RenderSetup.firstRenderLayer = utils.createDstMsgAttr( 'firstRenderLayer', 'frl') RenderSetup.addAttribute(RenderSetup.firstRenderLayer) RenderSetup.lastRenderLayer = utils.createDstMsgAttr( 'lastRenderLayer', 'lrl') RenderSetup.addAttribute(RenderSetup.lastRenderLayer)
def postConstructor(self): """ Method running after the node is constructed. All initialization that will access the MObject or other methods of the MPxNode must be done here. Since the node is not fully created until after the call to __init__ """ # Call parent class postConstructor super(MaterialOverride, self).postConstructor() # Create the value attribute as a message attribute attrObj = utils.createDstMsgAttr(ConnectionOverride.kAttrValueLong, ConnectionOverride.kAttrValueShort) fn = OpenMaya.MFnDependencyNode(self.thisMObject()) fn.addAttribute(attrObj)
def initializer(): ApplyConnectionOverride.inheritAttributesFrom( applyOverride.ApplyOverride.kTypeName) ApplyConnectionOverride.aTarget = utils.createGenericAttr( "target", "tg") # Input attribute for chaining nodes ApplyConnectionOverride.aPrevious = utils.createDstMsgAttr( "previous", "p") # Output attribute for chaining nodes ApplyConnectionOverride.aNext = utils.createSrcMsgAttr("next", "n") ApplyConnectionOverride.addAttribute(ApplyConnectionOverride.aTarget) ApplyConnectionOverride.addAttribute(ApplyConnectionOverride.aPrevious) ApplyConnectionOverride.addAttribute(ApplyConnectionOverride.aNext)
def postConstructor(layer): # backward compatibility for when layers derived from overrideManager class # They were defined as: # " # The overrideManager class has an array of override elements that represents the overrides currently applied to # the scene where each such element holds a connection from the target attribute (the attribute being overridden) # and a connection from the apply node operating on that attribute. If there are more than one apply node # operating on the same target attribute they form a chain where the first one in the chain is connected to the element. # " # i.e. They were the end point of the apply connection override nodes # layer._backwardCompID = None if OpenMaya1_0.MFileIO.isReadingFile(): # if file was saved in a visible layer with override manager attributes used (i.e. connection override using layer as override manager), # then opening file will fail if these attributes are missing. # 1) Create dynamic attribute array on file open # 2) Transfer them to the apply nodes after file open (all apply overrides hold original and most prioritary override hold target) # 3) Remove dynamic attributes array fnCompoundAttr = OpenMaya.MFnCompoundAttribute() aOverrides = fnCompoundAttr.create("overrides", "ovrs") aTarget = utils.createGenericAttr("target", "tg") aApplyNode = utils.createDstMsgAttr("applyNode", "an") fnCompoundAttr.addChild(aTarget) fnCompoundAttr.addChild(aApplyNode) fnCompoundAttr.array = True OpenMaya.MFnDependencyNode(layer.thisMObject()).addAttribute(aOverrides) if not OpenMaya1_0.MFileIO.isReferencingFile(): handle = OpenMaya.MObjectHandle(layer.thisMObject()) def transferAttributes(clientData=None): if layer._backwardCompID is None: return OpenMaya.MSceneMessage.removeCallback(layer._backwardCompID) layer._backwardCompID = None if not handle.isValid(): # layer was destroyed before the end of file open return arrayPlug = OpenMaya.MPlug(layer.thisMObject(), aOverrides) for i in xrange(arrayPlug.evaluateNumElements()): plug = arrayPlug.elementByLogicalIndex(i) target = plug.child(aTarget) applyOv = plug.child(aApplyNode) # target and applyOv plugs are always as a pair. # # Since apply override nodes are always in the scene # (never referenced, and thus never unloaded), the # connection to them must exist. # # The target plug is different: if the target pointed # to a referenced node, that node might not be loaded, # and thus target would not be connected. For versions # of Maya where this code applies, there is no way to # recover the target by name, so the whole apply # override node chain is stale, and should be removed. # Otherwise, connection apply override unapply code # pre-conditions and invariants cannot be guaranteed. # # Correctness is still obtained through brute force # post-read re-application of the render layer (see # model.renderSetup.RenderSetup._afterOpenCB). ao = OpenMaya.MFnDependencyNode( applyOv.source().node()).userNode() if target.isConnected: ao.connectTarget(target.source()) utils.disconnect(target.source(), target) utils.disconnect(applyOv.source(), applyOv) else: # Apply override node chain is stale. Get rid of it. # This will disconnect applyOv from its source. deleteApplyOverrideChain(ao) OpenMaya.MFnDependencyNode(layer.thisMObject()).removeAttribute(aOverrides) # transferAttributes is a closure around declared variables in this function (postConstructor) # That's why it can still reference them when called on after open callback # It's a call-once function (called after file open). # (Attributes only need to be transfered once, applying layers later on will no longer use the layer as override manager) layer._transferAttributes = transferAttributes layer._backwardCompID = OpenMaya.MSceneMessage.addCallback(OpenMaya.MSceneMessage.kAfterOpen, layer._transferAttributes, None)