class LayerData(object): ''' Intermediate data object between ngSkinTools core and importers/exporters, representing all layers info in one skin cluster. .. py:attribute:: layers a list of :py:class:`Layer` objects. .. py:attribute:: influences a list of :py:class:`InfluenceInfo` objects. Provides information about influences that were found on exported skin data, and used for influence matching when importing. ''' def __init__(self): self.layers = [] self.mll = MllInterface() self.meshInfo = MeshInfo() self.influences = [] # a map [sourceInfluenceName] -> [destinationInfluenceName] self.mirrorInfluenceAssociationOverrides = None self.skinClusterFn = None def addMirrorInfluenceAssociationOverride(self, sourceInfluence, destinationInfluence=None, selfReference=False, bidirectional=True): ''' Adds mirror influence association override, similar to UI of "Add influences association". Self reference creates a source<->source association, bidirectional means that destination->source link is added as well ''' if self.mirrorInfluenceAssociationOverrides is None: self.mirrorInfluenceAssociationOverrides = {} if selfReference: self.mirrorInfluenceAssociationOverrides[ sourceInfluence] = sourceInfluence return if destinationInfluence is None: raise MessageException("destination influence must be specified") self.mirrorInfluenceAssociationOverrides[ sourceInfluence] = destinationInfluence if bidirectional: self.mirrorInfluenceAssociationOverrides[ destinationInfluence] = sourceInfluence def addLayer(self, layer): ''' register new layer into this data object :param Layer layer: layer object to add. ''' assert isinstance(layer, Layer) self.layers.append(layer) @staticmethod def getFullNodePath(nodeName): result = cmds.ls(nodeName, l=True) if result is None or len(result) == 0: raise MessageException("node %s was not found" % nodeName) return result[0] def loadInfluenceInfo(self): self.influences = self.mll.listInfluenceInfo() def loadFrom(self, mesh): ''' loads data from actual skin cluster and prepares it for exporting. supply skin cluster or skinned mesh as an argument ''' self.mll.setCurrentMesh(mesh) meshExporter = MeshDataExporter() self.meshInfo = MeshInfo() if mesh != MllInterface.TARGET_REFERENCE_MESH: mesh, skinCluster = self.mll.getTargetInfo() meshExporter.setTransformMatrixFromNode(mesh) meshExporter.useSkinClusterInputMesh(skinCluster) self.meshInfo.verts, self.meshInfo.triangles = meshExporter.export( ) else: self.meshInfo.verts = self.mll.getReferenceMeshVerts() self.meshInfo.triangles = self.mll.getReferenceMeshTriangles() self.loadInfluenceInfo() # map LayerId->layerIndex layerIndexById = {} for index, (layerID, layerName, parentId) in enumerate(self.mll.listLayers()): layerIndexById[layerID] = index self.mirrorInfluenceAssociationOverrides = self.mll.getManualMirrorInfluences( ) if len(self.mirrorInfluenceAssociationOverrides) == 0: self.mirrorInfluenceAssociationOverrides = None layer = Layer() layer.name = layerName self.addLayer(layer) layer.opacity = self.mll.getLayerOpacity(layerID) layer.enabled = self.mll.isLayerEnabled(layerID) layer.mask = self.mll.getLayerMask(layerID) layer.dqWeights = self.mll.getDualQuaternionWeights(layerID) # transform parent ID to local index in the model if parentId is not None: layer.parent = layerIndexById[parentId] for inflName, logicalIndex in self.mll.listLayerInfluences( layerID, activeInfluences=True): if inflName == '': inflName = None influence = Influence() if inflName is not None: influence.influenceName = self.getFullNodePath(inflName) influence.logicalIndex = logicalIndex layer.addInfluence(influence) influence.weights = self.mll.getInfluenceWeights( layerID, logicalIndex) def __validate(self): numVerts = self.mll.getVertCount() def validateVertCount(count, message): if count != numVerts: raise Exception(message) for layer in self.layers: if layer.mask is not None and len(layer.mask) != 0: validateVertCount( len(layer.mask), "Invalid vertex count for mask in layer '%s': expected size is %d" % (layer.name, numVerts)) for influence in layer.influences: validateVertCount( len(influence.weights), "Invalid weights count for influence '%s' in layer '%s': expected size is %d" % (influence.influenceName, layer.name, numVerts)) if self.skinClusterFn: influence.logicalIndex = self.skinClusterFn.getLogicalInfluenceIndex( influence.influenceName) @Utils.undoable def saveTo(self, mesh): ''' saveTo(self,mesh) saves data to actual skin cluster ''' # set target to whatever was provided self.mll.setCurrentMesh(mesh) if mesh == MllInterface.TARGET_REFERENCE_MESH: self.mll.setWeightsReferenceMesh(self.meshInfo.verts, self.meshInfo.triangles) if not self.mll.getLayersAvailable(): self.mll.initLayers() if not self.mll.getLayersAvailable(): raise Exception("could not initialize layers") # is skin cluster available? if mesh != MllInterface.TARGET_REFERENCE_MESH: mesh, self.skinCluster = self.mll.getTargetInfo() self.skinClusterFn = SkinClusterFn() self.skinClusterFn.setSkinCluster(self.skinCluster) self.__validate() # set target to actual mesh self.mll.setCurrentMesh(mesh) with self.mll.batchUpdateContext(): if self.mirrorInfluenceAssociationOverrides: self.mll.setManualMirrorInfluences( self.mirrorInfluenceAssociationOverrides) # IDS of created layers, in reverse order layerIds = [] for layer in reversed(self.layers): layerId = self.mll.createLayer(name=layer.name, forceEmpty=True) layerIds.append(layerId) self.mll.setCurrentLayer(layerId) if layerId is None: raise Exception( "import failed: could not create layer '%s'" % (layer.name)) self.mll.setLayerOpacity(layerId, layer.opacity) self.mll.setLayerEnabled(layerId, layer.enabled) self.mll.setLayerMask(layerId, layer.mask) self.mll.setDualQuaternionWeights(layerId, layer.dqWeights) self.mll.setLayerWeightsBufferSize(layerId, len(layer.influences)) for influence in layer.influences: # because layer was just created and will belong to same undo chunk, disabling undo # for setting weights bit self.mll.setInfluenceWeights(layerId, influence.logicalIndex, influence.weights, undoEnabled=False) # layer.parent reference index is in normal order, therefore need to reverse it again layerIds = list(reversed(layerIds)) for index, layer in enumerate(self.layers): if layer.parent is not None: self.mll.setLayerParent(layerIds[index], layerIds[layer.parent]) # reparenting will move it to the end of the list; move it to the bottom instead self.mll.setLayerIndex(layerIds[index], 0) def __repr__(self): return "[LayerDataModel(%r)]" % self.layers def getAllInfluences(self): ''' a convenience method to retrieve a list of names of all influences used in this layer data object ''' result = set() for layer in self.layers: for influence in layer.influences: result.add(influence.influenceName) return tuple(result)
class LayerDataModel: log = getLogger("layerDataModel") # holds instance of singleton object __instance = None @staticmethod def getInstance(): ''' returns singleton instance of LayerDataModel :rtype: LayerDataModel ''' return LayerDataModel.__instance @classmethod def bindAll(cls): cls.__instance = LayerDataModel() MayaEvents.undoRedoExecuted.addHandler( cls.__instance.updateLayerAvailability) MayaEvents.nodeSelectionChanged.addHandler( cls.__instance.updateLayerAvailability) cls.__instance.updateLayerAvailability() def __init__(self): self.layerDataAvailable = None self.mll = MllInterface() self.clipboard = WeightsClipboard(self.mll) def setLayerListsUI(self, ui): self.layerListsUI = ui def getLayerListsUI(self): ''' :rtype: LayerListsUI ''' from ngSkinTools.ui import mainwindow mainWindow = mainwindow.MainWindow.getInstance() if mainWindow is None: return None return mainWindow.getLayersUI() def getSelectedLayer(self): listsUi = self.getLayerListsUI() if listsUi is None: return None return listsUi.getLayersList().getSelectedID() def getSelectedLayers(self): listsUi = self.getLayerListsUI() if listsUi is None: return [] return listsUi.getSelectedLayers() def getSelectedInfluenceIds(self): listsUi = self.getLayerListsUI() if listsUi is None: return [] return listsUi.getSelectedInfluenceIds() def updateLayerAvailability(self): ''' checks if availability of skin layers changed with the current scene selection ''' self.log.info("updating layer availability") oldValue = self.layerDataAvailable self.layerDataAvailable = self.mll.getLayersAvailable() if self.layerDataAvailable != oldValue: LayerEvents.layerAvailabilityChanged.emit() @Utils.undoable def addLayer(self, name): def guessParent(): currentLayer = self.mll.getCurrentLayer() if currentLayer is None: return None # guess layer's new parent parentsByLayerId = dict([ (layerId, parentId) for layerId, _, parentId in self.mll.listLayers() if currentLayer in (layerId, parentId) ]) # current layer is a parent? if currentLayer in parentsByLayerId.values(): return currentLayer # current layer has parent if currentLayer in parentsByLayerId.keys(): return parentsByLayerId[currentLayer] layerId = self.mll.createLayer(name) self.mll.setLayerParent(layerId, guessParent()) if layerId is None: return None LayerEvents.layerListModified.emit() self.setCurrentLayer(layerId) return layerId def removeLayer(self, layerId): self.mll.deleteLayer(layerId) LayerEvents.layerListModified.emit() LayerEvents.currentLayerChanged.emit() def setCurrentLayer(self, layerId): self.mll.setCurrentLayer(layerId) LayerEvents.currentLayerChanged.emit() def getCurrentLayer(self): return self.mll.getCurrentLayer() def attachLayerData(self): self.mll.initLayers() with self.mll.batchUpdateContext(): self.addLayer('Base Weights') self.updateLayerAvailability() selectionState.selectionInfo.dropCache() def cleanCustomNodes(self): ''' removes all custom nodes from current scene ''' # just in case we were in the middle of painting cmds.setToolTo('selectSuperContext') LayerUtils.deleteCustomNodes() # notify the rest of the world self.updateLayerAvailability() selectionState.selectionInfo.dropCache() def getLayerName(self, layerId): return mel.eval('ngSkinLayer -id {0} -q -name'.format(int(layerId))) def setLayerName(self, layerId, name): self.mll.setLayerName(layerId, name) LayerEvents.nameChanged.emit() def getLayerOpacity(self, layerId): return mel.eval('ngSkinLayer -id {0} -q -opacity'.format(layerId)) def getLayerEnabled(self, layerId): return mel.eval('ngSkinLayer -id {0} -q -enabled'.format(layerId)) def setLayerEnabled(self, layerId, enabled): cmds.ngSkinLayer(e=True, id=layerId, enabled=1 if enabled else 0) def toggleLayerEnabled(self, layerId): self.setLayerEnabled(layerId, not self.getLayerEnabled(layerId)) def getLayersCandidateFromSelection(self): ''' for given selection, returns mesh and skin cluster node names where skinLayer data is (or can be) attached. ''' return self.mll.getTargetInfo() def getLayersAvailable(self): self.updateLayerAvailability() return self.layerDataAvailable def isDqMode(self): ''' returns True if current skin cluster is operating in dual quaternion mode ''' target = self.mll.getTargetInfo() if not target: return False skinCluster = target[1] return cmds.skinCluster(skinCluster, q=True, skinMethod=True) == 2