Exemplo n.º 1
0
    def createWindow(self):
        BaseToolWindow.createWindow(self)

        buttons = [('Close', self.closeWindow, '')]

        self.cmdLayout = CommandLayout(SkinToolsDocs.MIRRORWEIGHTS_INTERFACE,
                                       buttons)

        contentRoot = self.cmdLayout.innerLayout

        self.influenceMappingPreview.mirrorMode = True
        self.influenceMappingPreview.createUI(contentRoot)
        self.influenceMappingPreview.onDelete.addHandler(
            self.influencesManualMapping.removeSelectedManualMappings,
            contentRoot)

        manualGroup = uiGroup.create(contentRoot, 'Manual influence mapping')
        self.influencesManualMapping.mirrorMode = True
        self.influencesManualMapping.createUI(manualGroup)
        self.influencesManualMapping.getSelectedInfluences = lambda: self.influenceMappingPreview.currentInfluencesSelection

        def onManualOverridesChanged():
            mll = MllInterface()
            mll.setManualMirrorInfluences(
                self.influencesManualMapping.manualOverrides)
            self.previewInfluenceMapping()

        self.influencesManualMapping.manualOverridesChanged.addHandler(
            onManualOverridesChanged, contentRoot)

        def updateForSelectionInfoChange():
            log.info("updating for selection change")
            layersAvailable = selectionState.getLayersAvailable()
            cmds.layout(contentRoot, e=True, enable=layersAvailable)
            if not layersAvailable:
                log.info("layers unavailable")
                return

            self.previewInfluenceMapping()

        selectionState.selectionInfo.changed.addHandler(
            updateForSelectionInfoChange, contentRoot)
        selectionState.mirrorInfo.changed.addHandler(
            self.previewInfluenceMapping, contentRoot)
        updateForSelectionInfoChange()
Exemplo n.º 2
0
    def createInfluenceMappingGroup(self):
        group = self.createUIGroup(self.cmdLayout.innerLayout,
                                   'Influence Mapping')

        self.createFixedTitledRow(group, 'Infl. Distance Error')
        self.controls.influenceDistanceError = FloatField(
            self.VAR_PREFIX + 'distanceError',
            minValue=0,
            maxValue=None,
            step=0.01,
            defaultValue=0.001,
            annotation=
            'Defines maximum inaccuracy between left and right influence positions'
        )
        self.controls.influenceDistanceError.changeCommand.addHandler(
            self.previewInfluenceMapping, group)

        self.createTitledRow(parent=group, title="Namespaces")
        self.controls.ignoreNamespaces = CheckBoxField(
            self.VAR_PREFIX + 'IgnoreNamespaces',
            label="Ignore",
            annotation='ignore influence namespaces when matching by name',
            defaultValue=1)
        self.controls.ignoreNamespaces.changeCommand.addHandler(
            self.previewInfluenceMapping, ownerUI=group)

        self.influenceMappingPreview.mirrorMode = False
        self.influenceMappingPreview.createUI(parent=group)
        self.influenceMappingPreview.onDelete.addHandler(
            self.influencesManualMapping.removeSelectedManualMappings, group)

        manualGroup = uiGroup.create(self.cmdLayout.innerLayout,
                                     'Manual influence mapping')
        self.influencesManualMapping.mirrorMode = False
        self.influencesManualMapping.createUI(parent=manualGroup)
        self.influencesManualMapping.getSelectedInfluences = lambda: self.influenceMappingPreview.currentInfluencesSelection
        self.influencesManualMapping.manualOverridesChanged.addHandler(
            self.previewInfluenceMapping, group)

        cmds.setParent(group)
Exemplo n.º 3
0
    def createUI(self, parent):

        group = self.mirrorOptionsGroup = uiGroup.create(
            parent, 'Influences Mapping')

        titledRow.createFixed(group, 'Position Tolerance')
        self.influenceDistanceError = FloatField(
            self.VAR_PREFIX + 'distanceError',
            minValue=0,
            maxValue=None,
            step=0.01,
            defaultValue=0.001,
            annotation=
            'Defines maximum inaccuracy between left and right influence positions'
        )

        self.influencePrefixSuffixSelector = InfluencePrefixSuffixSelector()
        self.influencePrefixSuffixSelector.createUI(group)
        titledRow.createFixed(group, None)

        cmds.button(label="Edit influence associations...",
                    command=self.showEditInfluencesWindow)
Exemplo n.º 4
0
    def createUI(self, parent):
        group = self.rootGroup = uiGroup.create(parent, 'Vertex Mapping')
        titledRow.createFixed(group, 'Mirror Axis')
        self.mirrorAxis = DropDownField(self.VAR_PREFIX + 'mirrorAxis')
        self.mirrorAxis.setItems('X', 'Y', 'Z')
        self.mirrorAxis.changeCommand.addHandler(self.updateConfiguration,
                                                 parent)

        titledRow.create(parent=group, title="Mapping mode")
        cmds.columnLayout()
        self.transferMode = DropDownField(self.VAR_PREFIX +
                                          'vertexMirrorMappingMode')
        self.transferMode.setItems(*self.vertexTransferModes.keys())
        self.transferMode.changeCommand.addHandler(self.updateConfiguration,
                                                   parent)

        def update():
            mirrorAxis = selectionState.mirrorInfo.get()['axis']
            if mirrorAxis is not None:
                self.mirrorAxis.setValue(mirrorAxis.upper())

        selectionState.mirrorInfo.changed.addHandler(update, parent)

        update()
Exemplo n.º 5
0
    def createUI(self, parent):
        group = self.mirrorOptionsGroup = uiGroup.create(
            parent, 'Mirroring Options')

        titledRow.createFixed(group, 'Mirror direction')
        self.mirrorDirection = DropDownField(self.VAR_PREFIX +
                                             'mirrorDirection')

        def getMirrorSideTexts():
            axis = selectionState.mirrorInfo.get()['axis']
            if axis is None:
                axis = 'x'
            return self.MIRROR_TEXTS[axis]

        def rebuildMirrorDirectionDropDown():
            self.mirrorDirection.beginRebuildItems()
            self.mirrorDirection.addOption(self.MIRROR_GUESS)
            for mirrorText in getMirrorSideTexts():
                self.mirrorDirection.addOption(mirrorText)
            self.mirrorDirection.addOption(self.MIRROR_FLIP)
            self.mirrorDirection.endRebuildItems()

        selectionState.mirrorInfo.changed.addHandler(
            rebuildMirrorDirectionDropDown, parent)

        def updateEnabled():
            data = LayerDataModel.getInstance()
            self.mirrorDq.setEnabled(data.layerDataAvailable
                                     and data.isDqMode())

        MayaEvents.nodeSelectionChanged.addHandler(updateEnabled, parent)

        titledRow.createFixed(group, 'Mirror Seam Width')
        self.mirrorWidth = FloatField(
            self.VAR_PREFIX + 'mirrorWidth',
            minValue=0,
            maxValue=None,
            step=1.0,
            defaultValue=0.1,
            annotation=
            'Defines width of the interpolation from left to right side on the model center line.'
        )
        cmds.setParent(group)
        titledRow.create(group, 'Elements')
        self.mirrorWeights = CheckBoxField(
            self.VAR_PREFIX + 'MirrorWeights',
            label="Mirror weights",
            annotation=
            'Check this if mirror operation should be mirroring weights',
            defaultValue=1)
        self.mirrorMask = CheckBoxField(
            self.VAR_PREFIX + 'MirrorMask',
            label="Mirror mask",
            annotation=
            'Check this if mirror operation should be mirroring layer mask',
            defaultValue=1)
        self.mirrorDq = CheckBoxField(
            self.VAR_PREFIX + 'MirrorDualQuaternion',
            label="Mirror dual quaternion weights",
            annotation=
            'Check this if mirror operation should be mirroring dual quaternion weights',
            defaultValue=1)

        LayerEvents.mirrorConfigurationChanged.addHandler(
            rebuildMirrorDirectionDropDown, parent)
        rebuildMirrorDirectionDropDown()
        updateEnabled()