Exemplo n.º 1
0
    def __init__(self, name='Clavicle', parent=None):

        Profiler.getInstance().push("Construct Clavicle Rig Component:" + name)
        super(FabriceClavicleRig, self).__init__(name, parent)


        # =========
        # Controls
        # =========
        # Clavicle
        self.clavicleCtrlSpace = CtrlSpace('clavicle', parent=self.ctrlCmpGrp)
        self.clavicleCtrl = Control('clavicle', parent=self.clavicleCtrlSpace, shape="cube")
        self.clavicleCtrl.alignOnXAxis()


        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        defCmpGrp = ComponentGroup(self.getName(), self, parent=deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)

        self.clavicleDef = Joint('clavicle', parent=defCmpGrp)
        self.clavicleDef.setComponent(self)


        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        clavicleInputConstraint = PoseConstraint('_'.join([self.clavicleCtrl.getName(), 'To', self.spineEndInputTgt.getName()]))
        clavicleInputConstraint.setMaintainOffset(True)
        clavicleInputConstraint.addConstrainer(self.spineEndInputTgt)
        self.clavicleCtrlSpace.addConstraint(clavicleInputConstraint)

        # Constraint outputs
        clavicleConstraint = PoseConstraint('_'.join([self.clavicleOutputTgt.getName(), 'To', self.clavicleCtrl.getName()]))
        clavicleConstraint.addConstrainer(self.clavicleCtrl)
        self.clavicleOutputTgt.addConstraint(clavicleConstraint)


        # ===============
        # Add Canvas Ops
        # ===============
        # Add Deformer Canvas Op
        self.defConstraintOp = KLOperator('defConstraint', 'PoseConstraintSolver', 'Kraken')
        self.addOperator(self.defConstraintOp)

        # Add Att Inputs
        self.defConstraintOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.defConstraintOp.setInput('rigScale', self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.defConstraintOp.setInput('constrainer', self.clavicleOutputTgt)

        # Add Xfo Outputs
        self.defConstraintOp.setOutput('constrainee', self.clavicleDef)

        Profiler.getInstance().pop()
Exemplo n.º 2
0
    def __init__(self, name='Hand', parent=None):

        Profiler.getInstance().push("Construct Hand Rig Component:" + name)
        super(HandComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # Hand
        self.handCtrlSpace = CtrlSpace('hand', parent=self.ctrlCmpGrp)
        self.handCtrl = Control('hand',
                                parent=self.handCtrlSpace,
                                shape="square")
        self.handCtrl.rotatePoints(0, 0, 90.0)
        self.handCtrl.lockScale(True, True, True)
        self.handCtrl.lockTranslation(True, True, True)

        # ==========
        # Deformers
        # ==========
        self.deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=self.deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)

        self.handDef = Joint('hand', parent=self.defCmpGrp)
        self.handDef.setComponent(self)

        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        self.armEndInputConstraint = PoseConstraint('_'.join([
            self.handCtrlSpace.getName(), 'To',
            self.armEndInputTgt.getName()
        ]))
        self.armEndInputConstraint.setMaintainOffset(True)
        self.armEndInputConstraint.addConstrainer(self.armEndInputTgt)
        self.handCtrlSpace.addConstraint(self.armEndInputConstraint)

        # Constraint outputs
        self.handOutputConstraint = PoseConstraint('_'.join(
            [self.handOutputTgt.getName(), 'To',
             self.handCtrl.getName()]))
        self.handOutputConstraint.addConstrainer(self.handCtrl)
        self.handOutputTgt.addConstraint(self.handOutputConstraint)

        # Constraint deformers
        self.handDefConstraint = PoseConstraint('_'.join(
            [self.handDef.getName(), 'To',
             self.handCtrl.getName()]))
        self.handDefConstraint.addConstrainer(self.handCtrl)
        self.handDef.addConstraint(self.handDefConstraint)

        Profiler.getInstance().pop()
Exemplo n.º 3
0
    def __init__(self, name='', parent=None, *args, **kwargs):
        super(BaseExampleComponent, self).__init__(name, parent, *args, **kwargs)

        # ================
        # Setup Hierarchy
        # ================
        self.controlsLayer = self.getOrCreateLayer('controls')
        self.ctrlCmpGrp = ComponentGroup(self.getName(), self, parent=self.controlsLayer)
        self.addItem('ctrlCmpGrp', self.ctrlCmpGrp)

        # IO Hierarchies
        self.inputHrcGrp = HierarchyGroup('inputs', parent=self.ctrlCmpGrp)
        self.cmpInputAttrGrp = AttributeGroup('inputs', parent=self.inputHrcGrp)

        self.outputHrcGrp = HierarchyGroup('outputs', parent=self.ctrlCmpGrp)
        self.cmpOutputAttrGrp = AttributeGroup('outputs', parent=self.outputHrcGrp)
Exemplo n.º 4
0
    def __init__(self, name='Tentacle', parent=None):

        Profiler.getInstance().push("Construct Tentacle Rig Component:" + name)
        super(TentacleComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========

        # Chain Base
        self.chainBase = Locator('ChainBase', parent=self.ctrlCmpGrp)
        self.chainBase.setShapeVisibility(False)

        # FK
        self.fkCtrlSpaces = []
        self.fkCtrls = []
        self.setNumControls(2)

        # IK Control
        self.tentacleIKCtrlSpace = CtrlSpace('IK', parent=self.ctrlCmpGrp)
        self.tentacleIKCtrl = Control('IK',
                                      parent=self.tentacleIKCtrlSpace,
                                      shape="sphere")
        self.tentacleIKCtrl.scalePoints(Vec3(0.25, 0.25, 0.25))
        self.tentacleIKCtrl.lockScale(x=True, y=True, z=True)
        self.tentacleIKCtrl.lockRotation(x=True, y=True, z=True)

        # Add Component Params to IK control
        tentacleSettingsAttrGrp = AttributeGroup("DisplayInfo_LegSettings",
                                                 parent=self.tentacleIKCtrl)
        tentacledrawDebugInputAttr = BoolAttribute(
            'drawDebug', value=False, parent=tentacleSettingsAttrGrp)
        fkikInputAttr = ScalarAttribute('fkik',
                                        value=0.0,
                                        minValue=0.0,
                                        maxValue=1.0,
                                        parent=tentacleSettingsAttrGrp)
        waveLength_YInputAttr = ScalarAttribute('waveLength_Y',
                                                value=1.0,
                                                minValue=0.0,
                                                maxValue=5.0,
                                                parent=tentacleSettingsAttrGrp)
        waveAmplitude_YInputAttr = ScalarAttribute(
            'waveAmplitude_Y',
            value=0.0,
            minValue=-3.0,
            maxValue=3.0,
            parent=tentacleSettingsAttrGrp)
        waveFrequency_YInputAttr = ScalarAttribute(
            'waveFrequency_Y',
            value=2.0,
            minValue=0.0,
            maxValue=10.0,
            parent=tentacleSettingsAttrGrp)
        waveLength_ZInputAttr = ScalarAttribute('waveLength_Z',
                                                value=2.329,
                                                minValue=0.0,
                                                maxValue=5.0,
                                                parent=tentacleSettingsAttrGrp)
        waveAmplitude_ZInputAttr = ScalarAttribute(
            'waveAmplitude_Z',
            value=0.0,
            minValue=-3.0,
            maxValue=3.0,
            parent=tentacleSettingsAttrGrp)
        waveFrequency_ZInputAttr = ScalarAttribute(
            'waveFrequency_Z',
            value=3.354,
            minValue=0.0,
            maxValue=10.0,
            parent=tentacleSettingsAttrGrp)
        tipBiasInputAttr = ScalarAttribute('tipBias',
                                           value=1.0,
                                           minValue=0.0,
                                           maxValue=1.0,
                                           parent=tentacleSettingsAttrGrp)

        springStrengthInputAttr = ScalarAttribute(
            'springStrength',
            value=0.3,
            minValue=0.0,
            maxValue=1.0,
            parent=tentacleSettingsAttrGrp)
        dampeningInputAttr = ScalarAttribute('dampening',
                                             value=0.03,
                                             minValue=0.0,
                                             maxValue=1.0,
                                             parent=tentacleSettingsAttrGrp)
        simulationWeightInputAttr = ScalarAttribute(
            'simulationWeight',
            value=1.0,
            minValue=0.0,
            maxValue=1.0,
            parent=tentacleSettingsAttrGrp)
        softLimitBoundsInputAttr = ScalarAttribute(
            'softLimitBounds',
            value=5.0,
            minValue=0.0,
            maxValue=10.0,
            parent=tentacleSettingsAttrGrp)

        # Connect IO to controls
        self.drawDebugInputAttr.connect(tentacledrawDebugInputAttr)

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)
        self.deformerJoints = []
        self.boneOutputsTgt = []
        self.setNumDeformers(4)

        # =====================
        # Create Component I/O
        # =====================

        # Set IO Targets
        self.boneOutputs.setTarget(self.boneOutputsTgt)

        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        tentacleRootInputConstraint = PoseConstraint('_'.join([
            self.fkCtrlSpaces[0].getName(), 'To',
            self.rootInputTgt.getName()
        ]))
        tentacleRootInputConstraint.setMaintainOffset(True)
        tentacleRootInputConstraint.addConstrainer(self.rootInputTgt)
        self.fkCtrlSpaces[0].addConstraint(tentacleRootInputConstraint)

        tentacleRootInputConstraint = PoseConstraint('_'.join([
            self.tentacleIKCtrlSpace.getName(), 'To',
            self.rootInputTgt.getName()
        ]))
        tentacleRootInputConstraint.setMaintainOffset(True)
        tentacleRootInputConstraint.addConstrainer(self.rootInputTgt)
        self.tentacleIKCtrlSpace.addConstraint(tentacleRootInputConstraint)

        chainBaseInputConstraint = PoseConstraint('_'.join(
            [self.chainBase.getName(), 'To',
             self.rootInputTgt.getName()]))
        chainBaseInputConstraint.setMaintainOffset(True)
        chainBaseInputConstraint.addConstrainer(self.rootInputTgt)
        self.chainBase.addConstraint(chainBaseInputConstraint)

        # ===============
        # Add Canvas Ops
        # ===============
        # Add Canvas Op
        self.tentacleSolverKLOp = KLOperator('tentacle', 'TentacleSolver',
                                             'Kraken')
        self.addOperator(self.tentacleSolverKLOp)

        # # Add Att Inputs
        self.tentacleSolverKLOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.tentacleSolverKLOp.setInput('rigScale', self.rigScaleInputAttr)
        self.tentacleSolverKLOp.setInput('ikblend', fkikInputAttr)
        self.tentacleSolverKLOp.setInput('waveLength_Y', waveLength_YInputAttr)
        self.tentacleSolverKLOp.setInput('waveAmplitude_Y',
                                         waveAmplitude_YInputAttr)
        self.tentacleSolverKLOp.setInput('waveFrequency_Y',
                                         waveFrequency_YInputAttr)
        self.tentacleSolverKLOp.setInput('waveLength_Z', waveLength_ZInputAttr)
        self.tentacleSolverKLOp.setInput('waveAmplitude_Z',
                                         waveAmplitude_ZInputAttr)
        self.tentacleSolverKLOp.setInput('waveFrequency_Z',
                                         waveFrequency_ZInputAttr)
        self.tentacleSolverKLOp.setInput('tipBias', tipBiasInputAttr)

        self.tentacleSolverKLOp.setInput('springStrength',
                                         springStrengthInputAttr)
        self.tentacleSolverKLOp.setInput('dampening', dampeningInputAttr)
        self.tentacleSolverKLOp.setInput('simulationWeight',
                                         simulationWeightInputAttr)
        self.tentacleSolverKLOp.setInput('softLimitBounds',
                                         softLimitBoundsInputAttr)

        self.tentacleSolverKLOp.setInput('tipBoneLen',
                                         self.tipBoneLenInputAttr)

        # Add Xfo Inputs
        self.tentacleSolverKLOp.setInput('chainBase', self.chainBase)
        self.tentacleSolverKLOp.setInput('ikgoal', self.tentacleIKCtrl)

        self.tentacleSolverKLOp.setInput('fkcontrols', self.fkCtrls)

        # Add Xfo Outputs
        self.tentacleSolverKLOp.setOutput('pose', self.boneOutputsTgt)

        self.tentacleSolverKLOp.setOutput('tentacleEnd',
                                          self.tentacleEndXfoOutputTgt)

        # Add Deformer Canvas Op
        self.outputsToDeformersKLOp = KLOperator('defConstraint',
                                                 'MultiPoseConstraintSolver',
                                                 'Kraken')
        self.addOperator(self.outputsToDeformersKLOp)

        # Add Att Inputs
        self.outputsToDeformersKLOp.setInput('drawDebug',
                                             self.drawDebugInputAttr)
        self.outputsToDeformersKLOp.setInput('rigScale',
                                             self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.outputsToDeformersKLOp.setInput('constrainers',
                                             self.boneOutputsTgt)

        # Add Xfo Outputs
        self.outputsToDeformersKLOp.setOutput('constrainees',
                                              self.deformerJoints)

        Profiler.getInstance().pop()
Exemplo n.º 5
0
    def __init__(self, name='MultiSpring', parent=None):

        Profiler.getInstance().push("Construct Multi Spring Rig Component:" +
                                    name)
        super(MultiSpringComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # Spring Ctrls
        self.mainSpringCtrl = Control('springSettings',
                                      parent=self.ctrlCmpGrp,
                                      shape='pin')

        self.springCtrlSpaces = []
        self.springCtrls = []
        self.setNumControls(1)

        # Add Component Params to FK control
        springSettingsAttrGrp = AttributeGroup("DisplayInfo_SpringSettings",
                                               parent=self.mainSpringCtrl)
        self.springDrawDebugInputAttr = BoolAttribute(
            'drawDebug', value=False, parent=springSettingsAttrGrp)
        self.springtargetOffsetXInputAttr = ScalarAttribute(
            'targetOffset_X',
            value=3.0,
            minValue=0.0,
            maxValue=10.0,
            parent=springSettingsAttrGrp)
        self.springtargetOffsetYInputAttr = ScalarAttribute(
            'targetOffset_Y',
            value=0.0,
            minValue=0.0,
            maxValue=10.0,
            parent=springSettingsAttrGrp)
        self.springtargetOffsetZInputAttr = ScalarAttribute(
            'targetOffset_Z',
            value=0.0,
            minValue=0.0,
            maxValue=10.0,
            parent=springSettingsAttrGrp)
        self.springFrameInputAttr = IntegerAttribute(
            'frame', value=1, parent=springSettingsAttrGrp)
        self.springResetFrameInputAttr = IntegerAttribute(
            'reset_frame', value=1, parent=springSettingsAttrGrp)
        self.springMassInputAttr = ScalarAttribute(
            'mass',
            value=0.5,
            minValue=0.0,
            maxValue=20.0,
            parent=springSettingsAttrGrp)
        self.springSpringStrengthInputAttr = ScalarAttribute(
            'springStrength',
            value=6.0,
            minValue=0.0,
            maxValue=20.0,
            parent=springSettingsAttrGrp)
        self.springDampingInputAttr = ScalarAttribute(
            'damping',
            value=0.125,
            minValue=0.0,
            maxValue=5.0,
            parent=springSettingsAttrGrp)

        # Connect IO to controls
        self.drawDebugInputAttr.connect(self.springDrawDebugInputAttr)

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)
        self.deformerJoints = []
        self.boneOutputsTgt = []
        self.setNumDeformers(4)

        # =====================
        # Create Component I/O
        # =====================

        # Set IO Targets
        self.boneOutputs.setTarget(self.boneOutputsTgt)

        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        self.rootInputConstraint = PoseConstraint('_'.join([
            self.springCtrlSpaces[0].getName(), 'To',
            self.rootInputTgt.getName()
        ]))
        self.rootInputConstraint.setMaintainOffset(True)
        self.rootInputConstraint.addConstrainer(self.rootInputTgt)
        self.springCtrlSpaces[0].addConstraint(self.rootInputConstraint)

        # ===============
        # Add Splice Ops
        # ===============
        # Add Solver Canvas Op
        self.springOp = CanvasOperator('springSolverOp',
                                       'Kraken.Solvers.SpringOffsetSolver')
        self.addOperator(self.springOp)

        # Add Att Inputs
        self.springOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.springOp.setInput('rigScale', self.rigScaleInputAttr)
        self.springOp.setInput('targetOffset_X',
                               self.springtargetOffsetXInputAttr)
        self.springOp.setInput('targetOffset_Y',
                               self.springtargetOffsetYInputAttr)
        self.springOp.setInput('targetOffset_Z',
                               self.springtargetOffsetZInputAttr)
        self.springOp.setInput('frame', self.springFrameInputAttr)
        self.springOp.setInput('reset_frame', self.springResetFrameInputAttr)
        self.springOp.setInput('mass', self.springMassInputAttr)
        self.springOp.setInput('spring_strength',
                               self.springSpringStrengthInputAttr)
        self.springOp.setInput('damping', self.springDampingInputAttr)

        # Add Xfo Inputs
        self.springOp.setInput('inputs', self.springCtrls)

        # Add Xfo Outputs
        self.springOp.setOutput('outputs', self.boneOutputsTgt)

        # Add Deformer Splice Op
        self.deformersToOutputsKLOp = KLOperator('springDeformerKLOp',
                                                 'MultiPoseConstraintSolver',
                                                 'Kraken')
        self.addOperator(self.deformersToOutputsKLOp)

        # Add Att Inputs
        self.deformersToOutputsKLOp.setInput('drawDebug', False)
        self.deformersToOutputsKLOp.setInput('rigScale',
                                             self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.deformersToOutputsKLOp.setInput('constrainers',
                                             self.boneOutputsTgt)

        # Add Xfo Outputs
        self.deformersToOutputsKLOp.setOutput('constrainees',
                                              self.deformerJoints)

        Profiler.getInstance().pop()
Exemplo n.º 6
0
    def __init__(self, name='arm', parent=None):

        Profiler.getInstance().push("Construct Arm Rig Component:" + name)
        super(ArmComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # Bicep
        self.bicepFKCtrlSpace = CtrlSpace('bicepFK', parent=self.ctrlCmpGrp)

        self.bicepFKCtrl = Control('bicepFK',
                                   parent=self.bicepFKCtrlSpace,
                                   shape="cube")
        self.bicepFKCtrl.alignOnXAxis()
        self.bicepFKCtrl.lockScale(True, True, True)
        self.bicepFKCtrl.lockTranslation(True, True, True)

        # Forearm
        self.forearmFKCtrlSpace = CtrlSpace('forearmFK',
                                            parent=self.bicepFKCtrl)

        self.forearmFKCtrl = Control('forearmFK',
                                     parent=self.forearmFKCtrlSpace,
                                     shape="cube")
        self.forearmFKCtrl.alignOnXAxis()
        self.forearmFKCtrl.lockScale(True, True, True)
        self.forearmFKCtrl.lockTranslation(True, True, True)

        # Arm IK
        self.armIKCtrlSpace = CtrlSpace('IK', parent=self.ctrlCmpGrp)
        self.armIKCtrl = Control('IK',
                                 parent=self.armIKCtrlSpace,
                                 shape="jack")
        self.armIKCtrl.scalePoints(Vec3(2.0, 2.0, 2.0))
        self.armIKCtrl.lockScale(True, True, True)

        # Add Params to IK control
        armSettingsAttrGrp = AttributeGroup("DisplayInfo_ArmSettings",
                                            parent=self.armIKCtrl)
        self.armDebugInputAttr = BoolAttribute('drawDebug',
                                               value=False,
                                               parent=armSettingsAttrGrp)
        self.armBone0LenInputAttr = ScalarAttribute('bone1Len',
                                                    value=0.0,
                                                    parent=armSettingsAttrGrp)
        self.armBone1LenInputAttr = ScalarAttribute('bone2Len',
                                                    value=0.0,
                                                    parent=armSettingsAttrGrp)
        self.armIKBlendInputAttr = ScalarAttribute('fkik',
                                                   value=0.0,
                                                   minValue=0.0,
                                                   maxValue=1.0,
                                                   parent=armSettingsAttrGrp)

        # Util Objects
        self.ikRootPosition = Transform("ikPosition", parent=self.ctrlCmpGrp)

        # Connect Input Attrs
        self.drawDebugInputAttr.connect(self.armDebugInputAttr)

        # Connect Output Attrs
        self.drawDebugOutputAttr.connect(self.armDebugInputAttr)
        self.ikBlendOutputAttr.connect(self.armIKBlendInputAttr)

        # UpV
        self.armUpVCtrlSpace = CtrlSpace('UpV', parent=self.ctrlCmpGrp)
        self.armUpVCtrl = Control('UpV',
                                  parent=self.armUpVCtrlSpace,
                                  shape="triangle")
        self.armUpVCtrl.alignOnZAxis()
        self.armUpVCtrl.rotatePoints(180, 0, 0)
        self.armIKCtrl.lockScale(True, True, True)
        self.armIKCtrl.lockRotation(True, True, True)

        # ==========
        # Deformers
        # ==========
        self.deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=self.deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)

        self.bicepDef = Joint('bicep', parent=self.defCmpGrp)
        self.bicepDef.setComponent(self)

        self.elbowDef = Joint('elbow', parent=self.defCmpGrp)
        self.elbowDef.setComponent(self)

        self.forearmDef = Joint('forearm', parent=self.defCmpGrp)
        self.forearmDef.setComponent(self)

        self.wristDef = Joint('wrist', parent=self.defCmpGrp)
        self.wristDef.setComponent(self)

        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        self.armIKCtrlSpaceInputConstraint = PoseConstraint('_'.join([
            self.armIKCtrlSpace.getName(), 'To',
            self.globalSRTInputTgt.getName()
        ]))
        self.armIKCtrlSpaceInputConstraint.setMaintainOffset(True)
        self.armIKCtrlSpaceInputConstraint.addConstrainer(
            self.globalSRTInputTgt)
        self.armIKCtrlSpace.addConstraint(self.armIKCtrlSpaceInputConstraint)

        self.armUpVCtrlSpaceInputConstraint = PoseConstraint('_'.join([
            self.armUpVCtrlSpace.getName(), 'To',
            self.globalSRTInputTgt.getName()
        ]))
        self.armUpVCtrlSpaceInputConstraint.setMaintainOffset(True)
        self.armUpVCtrlSpaceInputConstraint.addConstrainer(
            self.globalSRTInputTgt)
        self.armUpVCtrlSpace.addConstraint(self.armUpVCtrlSpaceInputConstraint)

        self.armRootInputConstraint = PoseConstraint('_'.join([
            self.bicepFKCtrlSpace.getName(), 'To',
            self.rootInputTgt.getName()
        ]))
        self.armRootInputConstraint.setMaintainOffset(True)
        self.armRootInputConstraint.addConstrainer(self.rootInputTgt)
        self.bicepFKCtrlSpace.addConstraint(self.armRootInputConstraint)

        self.ikPosInputConstraint = PoseConstraint('_'.join(
            [self.ikRootPosition.getName(), 'To',
             self.rootInputTgt.getName()]))
        self.ikPosInputConstraint.setMaintainOffset(True)
        self.ikPosInputConstraint.addConstrainer(self.rootInputTgt)
        self.ikRootPosition.addConstraint(self.ikPosInputConstraint)

        # Constraint outputs

        # ===============
        # Add Splice Ops
        # ===============
        # Add Splice Op
        self.armSolverKLOperator = KLOperator('ikSolver', 'TwoBoneIKSolver',
                                              'Kraken')
        self.addOperator(self.armSolverKLOperator)

        # Add Att Inputs
        self.armSolverKLOperator.setInput('drawDebug', self.drawDebugInputAttr)
        self.armSolverKLOperator.setInput('rigScale', self.rigScaleInputAttr)

        self.armSolverKLOperator.setInput('bone0Len',
                                          self.armBone0LenInputAttr)
        self.armSolverKLOperator.setInput('bone1Len',
                                          self.armBone1LenInputAttr)
        self.armSolverKLOperator.setInput('ikblend', self.armIKBlendInputAttr)
        self.armSolverKLOperator.setInput('rightSide', self.rightSideInputAttr)

        # Add Xfo Inputs
        self.armSolverKLOperator.setInput('root', self.ikRootPosition)
        self.armSolverKLOperator.setInput('bone0FK', self.bicepFKCtrl)
        self.armSolverKLOperator.setInput('bone1FK', self.forearmFKCtrl)
        self.armSolverKLOperator.setInput('ikHandle', self.armIKCtrl)
        self.armSolverKLOperator.setInput('upV', self.armUpVCtrl)

        # Add Xfo Outputs
        self.armSolverKLOperator.setOutput('bone0Out', self.bicepOutputTgt)
        self.armSolverKLOperator.setOutput('bone1Out', self.forearmOutputTgt)
        self.armSolverKLOperator.setOutput('bone2Out', self.wristOutputTgt)
        self.armSolverKLOperator.setOutput('midJointOut', self.elbowOutputTgt)

        # Add Deformer Splice Op
        self.outputsToDeformersKLOp = KLOperator('defConstraint',
                                                 'MultiPoseConstraintSolver',
                                                 'Kraken')
        self.addOperator(self.outputsToDeformersKLOp)

        # Add Att Inputs
        self.outputsToDeformersKLOp.setInput('drawDebug',
                                             self.drawDebugInputAttr)
        self.outputsToDeformersKLOp.setInput('rigScale',
                                             self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.outputsToDeformersKLOp.setInput('constrainers', [
            self.bicepOutputTgt, self.elbowOutputTgt, self.forearmOutputTgt,
            self.wristOutputTgt
        ])

        # Add Xfo Outputs
        self.outputsToDeformersKLOp.setOutput(
            'constrainees',
            [self.bicepDef, self.elbowDef, self.forearmDef, self.wristDef])

        Profiler.getInstance().pop()
Exemplo n.º 7
0
    def __init__(self, name="spine", parent=None):

        Profiler.getInstance().push("Construct Spine Rig Component:" + name)
        super(FabriceSpineRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # COG
        self.cogCtrlSpace = CtrlSpace('cog', parent=self.ctrlCmpGrp)
        self.cogCtrl = Control('cog', parent=self.cogCtrlSpace, shape="circle")
        self.cogCtrl.rotatePoints(90, 0, 0)
        self.cogCtrl.scalePoints(Vec3(3.0, 3.0, 3.0))
        self.cogCtrl.translatePoints(Vec3(0.0, 0.0, 0.2))
        self.cogCtrl.lockScale(x=True, y=True, z=True)
        self.cogCtrl.setColor("orange")

        # Spine Base
        self.spineBaseCtrlSpace = CtrlSpace('spineBase', parent=self.cogCtrl)
        self.spineBaseCtrl = Control('spineBase',
                                     parent=self.spineBaseCtrlSpace,
                                     shape="pin")
        self.spineBaseCtrl.rotatePoints(90, 0, 0)
        self.spineBaseCtrl.translatePoints(Vec3(0, 1.0, 0))
        self.spineBaseCtrl.lockScale(x=True, y=True, z=True)

        # Spine Base Handle
        self.spineBaseHandleCtrlSpace = CtrlSpace('spineBaseHandle',
                                                  parent=self.spineBaseCtrl)
        self.spineBaseHandleCtrl = Control(
            'spineBaseHandle',
            parent=self.spineBaseHandleCtrlSpace,
            shape="pin")
        self.spineBaseHandleCtrl.rotatePoints(90, 0, 0)
        self.spineBaseHandleCtrl.translatePoints(Vec3(0, 1.0, 0))
        self.spineBaseHandleCtrl.lockScale(x=True, y=True, z=True)
        self.spineBaseHandleCtrl.setColor("orange")

        # Spine End
        self.spineEndCtrlSpace = CtrlSpace('spineEnd', parent=self.cogCtrl)
        self.spineEndCtrl = Control('spineEnd',
                                    parent=self.spineEndCtrlSpace,
                                    shape="pin")
        self.spineEndCtrl.rotatePoints(90, 0, 0)
        self.spineEndCtrl.lockScale(x=True, y=True, z=True)
        self.spineEndCtrl.translatePoints(Vec3(0, 1.0, 0))

        # Spine End Handle
        self.spineEndHandleCtrlSpace = CtrlSpace('spineEndHandle',
                                                 parent=self.spineEndCtrl)
        self.spineEndHandleCtrl = Control('spineEndHandle',
                                          parent=self.spineEndHandleCtrlSpace,
                                          shape="pin")
        self.spineEndHandleCtrl.rotatePoints(90, 0, 0)
        self.spineEndHandleCtrl.translatePoints(Vec3(0, 1.0, 0))
        self.spineEndHandleCtrl.lockScale(x=True, y=True, z=True)
        self.spineEndHandleCtrl.setColor("orange")

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=deformersLayer)
        self.chestDef = Joint('chest', parent=self.defCmpGrp)
        self.chestDef.setComponent(self)

        self.deformerJoints = []
        self.spineOutputs = []
        self.setNumDeformers(1)

        # =====================
        # Create Component I/O
        # =====================
        # Setup component Xfo I/O's
        self.spineVertebraeOutput.setTarget(self.spineOutputs)

        # =====================
        # Constraint Deformers
        # =====================
        self.chestDefConstraint = PoseConstraint('_'.join(
            [self.chestDef.getName(), 'To',
             self.spineBaseOutputTgt.getName()]))
        self.chestDefConstraint.addConstrainer(self.spineBaseOutputTgt)
        self.chestDef.addConstraint(self.chestDefConstraint)

        # ==============
        # Constrain I/O
        # ==============

        # Constraint inputs
        self.spineSrtInputConstraint = PoseConstraint('_'.join([
            self.cogCtrlSpace.getName(), 'To',
            self.spineMainSrtInputTgt.getName()
        ]))
        self.spineSrtInputConstraint.addConstrainer(self.spineMainSrtInputTgt)
        self.spineSrtInputConstraint.setMaintainOffset(True)
        self.cogCtrlSpace.addConstraint(self.spineSrtInputConstraint)

        # Constraint outputs
        self.spineCogOutputConstraint = PoseConstraint('_'.join(
            [self.spineCogOutputTgt.getName(), 'To',
             self.cogCtrl.getName()]))
        self.spineCogOutputConstraint.addConstrainer(self.cogCtrl)
        self.spineCogOutputTgt.addConstraint(self.spineCogOutputConstraint)

        # Spine Base
        self.spineBaseOutputPosConstraint = PositionConstraint('_'.join([
            self.spineBaseOutputTgt.getName(), 'PosTo',
            self.spineOutputs[0].getName()
        ]))
        self.spineBaseOutputPosConstraint.addConstrainer(self.spineOutputs[0])
        self.spineBaseOutputTgt.addConstraint(
            self.spineBaseOutputPosConstraint)

        self.spineBaseOutputOriConstraint = OrientationConstraint('_'.join([
            self.spineBaseOutputTgt.getName(), 'PosTo',
            self.cogCtrl.getName()
        ]))
        self.spineBaseOutputOriConstraint.addConstrainer(self.cogCtrl)
        self.spineBaseOutputTgt.addConstraint(
            self.spineBaseOutputOriConstraint)

        # Spine End
        self.spineEndOutputConstraint = PoseConstraint('_'.join(
            [self.spineEndOutputTgt.getName(), 'To', 'spineEnd']))
        self.spineEndOutputConstraint.addConstrainer(self.spineOutputs[0])
        self.spineEndOutputTgt.addConstraint(self.spineEndOutputConstraint)

        self.spineEndCtrlOutputConstraint = PoseConstraint('_'.join([
            self.spineEndCtrlOutputTgt.getName(), 'To',
            self.spineEndCtrl.getName()
        ]))
        self.spineEndCtrlOutputConstraint.addConstrainer(self.spineEndCtrl)
        self.spineEndCtrlOutputTgt.addConstraint(
            self.spineEndCtrlOutputConstraint)

        # ===============
        # Add Splice Ops
        # ===============
        # Add Spine Splice Op
        self.bezierSpineSpliceOp = SpliceOperator('spineSpliceOp',
                                                  'BezierSpineSolver',
                                                  'Kraken')
        self.addOperator(self.bezierSpineSpliceOp)

        # Add Att Inputs
        self.bezierSpineSpliceOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.bezierSpineSpliceOp.setInput('rigScale', self.rigScaleInputAttr)
        self.bezierSpineSpliceOp.setInput('length', self.lengthInputAttr)

        # Add Xfo Inputs
        self.bezierSpineSpliceOp.setInput('base', self.spineBaseCtrl)
        self.bezierSpineSpliceOp.setInput('baseHandle',
                                          self.spineBaseHandleCtrl)
        self.bezierSpineSpliceOp.setInput('tipHandle', self.spineEndHandleCtrl)
        self.bezierSpineSpliceOp.setInput('tip', self.spineEndCtrl)

        # Add Xfo Outputs
        self.bezierSpineSpliceOp.setOutput('outputs', self.spineOutputs)

        # Add Deformer Splice Op
        self.deformersToOutputsSpliceOp = SpliceOperator(
            'spineDeformerSpliceOp',
            'MultiPoseConstraintSolver',
            'Kraken',
            alwaysEval=True)
        self.addOperator(self.deformersToOutputsSpliceOp)

        # Add Att Inputs
        self.deformersToOutputsSpliceOp.setInput('drawDebug',
                                                 self.drawDebugInputAttr)
        self.deformersToOutputsSpliceOp.setInput('rigScale',
                                                 self.rigScaleInputAttr)

        # Add Xfo Outputs
        self.deformersToOutputsSpliceOp.setInput('constrainers',
                                                 self.spineOutputs)

        # Add Xfo Outputs
        self.deformersToOutputsSpliceOp.setOutput('constrainees',
                                                  self.deformerJoints)

        Profiler.getInstance().pop()
Exemplo n.º 8
0
    def __init__(self, name="neck", parent=None):

        Profiler.getInstance().push("Construct Neck Rig Component:" + name)
        super(NeckComponentRig, self).__init__(name, parent)


        # =========
        # Controls
        # =========
        # Neck
        self.neckCtrlSpace = CtrlSpace('neck', parent=self.ctrlCmpGrp)
        self.neckCtrl = Control('neck', parent=self.neckCtrlSpace, shape="pin")
        self.neckCtrl.scalePoints(Vec3(1.25, 1.25, 1.25))
        self.neckCtrl.translatePoints(Vec3(0, 0, -0.5))
        self.neckCtrl.rotatePoints(90, 0, 90)
        self.neckCtrl.setColor("orange")


        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        defCmpGrp = ComponentGroup(self.getName(), self, parent=deformersLayer)

        neckDef = Joint('neck', parent=defCmpGrp)
        neckDef.setComponent(self)


        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        clavicleInputConstraint = PoseConstraint('_'.join([self.neckCtrlSpace.getName(), 'To', self.neckBaseInputTgt.getName()]))
        clavicleInputConstraint.setMaintainOffset(True)
        clavicleInputConstraint.addConstrainer(self.neckBaseInputTgt)
        self.neckCtrlSpace.addConstraint(clavicleInputConstraint)

        # Constraint outputs
        neckOutputConstraint = PoseConstraint('_'.join([self.neckOutputTgt.getName(), 'To', self.neckCtrl.getName()]))
        neckOutputConstraint.addConstrainer(self.neckCtrl)
        self.neckOutputTgt.addConstraint(neckOutputConstraint)

        neckEndConstraint = PoseConstraint('_'.join([self.neckEndOutputTgt.getName(), 'To', self.neckCtrl.getName()]))
        neckEndConstraint.addConstrainer(self.neckCtrl)
        self.neckEndOutputTgt.addConstraint(neckEndConstraint)


        # ===============
        # Add Splice Ops
        # ===============
        #Add Deformer Splice Op
        spliceOp = KLOperator('neckDeformerKLOp', 'PoseConstraintSolver', 'Kraken')
        self.addOperator(spliceOp)

        # Add Att Inputs
        spliceOp.setInput('drawDebug', self.drawDebugInputAttr)
        spliceOp.setInput('rigScale', self.rigScaleInputAttr)

        # Add Xfo Inputstrl)
        spliceOp.setInput('constrainer', self.neckEndOutputTgt)

        # Add Xfo Outputs
        spliceOp.setOutput('constrainee', neckDef)

        Profiler.getInstance().pop()
Exemplo n.º 9
0
    def __init__(self, name='FKCollision', parent=None):

        Profiler.getInstance().push("Construct FK Collision Rig Component:" +
                                    name)
        super(FKCollisionComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # Ground
        self.groundCtrl = Control('ground',
                                  parent=self.ctrlCmpGrp,
                                  shape='square')
        self.groundCtrl.insertCtrlSpace()

        groundSettingsAttrGrp = AttributeGroup("DisplayInfo_ChainSettings",
                                               parent=self.groundCtrl)
        self.groundOffsetYInputAttr = ScalarAttribute(
            'ground_offsetY',
            0.0,
            minValue=0.0,
            maxValue=10.0,
            parent=groundSettingsAttrGrp)

        # FK
        self.fkCtrlSpaces = []
        self.fkCtrls = []
        self.transforms = []
        self.setNumControls(4)
        self.setNumTransforms(4)

        # Add Component Params to FK control
        chainSettingsAttrGrp = AttributeGroup("DisplayInfo_ChainSettings",
                                              parent=self.fkCtrls[0])
        chainDrawDebugInputAttr = BoolAttribute('drawDebug',
                                                value=False,
                                                parent=chainSettingsAttrGrp)

        # Connect IO to controls
        self.drawDebugInputAttr.connect(chainDrawDebugInputAttr)

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)
        self.deformerJoints = []
        self.boneOutputsTgt = []
        self.setNumDeformers(4)

        # =====================
        # Create Component I/O
        # =====================

        # Set IO Targets
        self.boneOutputs.setTarget(self.boneOutputsTgt)

        # ==============
        # Constrain I/O
        # ==============
        # Constrain inputs
        self.rootInputConstraint = PoseConstraint('_'.join([
            self.fkCtrlSpaces[0].getName(), 'To',
            self.rootInputTgt.getName()
        ]))
        self.rootInputConstraint.setMaintainOffset(True)
        self.rootInputConstraint.addConstrainer(self.rootInputTgt)
        self.fkCtrlSpaces[0].addConstraint(self.rootInputConstraint)

        # ===============
        # Add Canvas Ops
        # ===============
        # Add Output Canvas Op
        self.collisionCanvasOp = CanvasOperator(
            'collisionCanvasOp', 'Kraken.Solvers.CollideChainSolver')
        self.addOperator(self.collisionCanvasOp)

        # Add Att Inputs
        self.collisionCanvasOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.collisionCanvasOp.setInput('rigScale', self.rigScaleInputAttr)
        self.collisionCanvasOp.setInput('ground_offsetY',
                                        self.groundOffsetYInputAttr)

        # Add Xfo Inputs
        self.collisionCanvasOp.setInput('ground', self.groundCtrl)
        self.collisionCanvasOp.setInput('joints', self.transforms)

        # Add Xfo Outputs
        self.collisionCanvasOp.setOutput('outputs', self.boneOutputsTgt)

        # Add Deformer Canvas Op
        self.deformersToOutputsKLOp = KLOperator('fkChainDeformerKLOp',
                                                 'MultiPoseConstraintSolver',
                                                 'Kraken')
        self.addOperator(self.deformersToOutputsKLOp)

        # Add Att Inputs
        self.deformersToOutputsKLOp.setInput('drawDebug', False)
        self.deformersToOutputsKLOp.setInput('rigScale',
                                             self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.deformersToOutputsKLOp.setInput('constrainers',
                                             self.boneOutputsTgt)

        # Add Xfo Outputs
        self.deformersToOutputsKLOp.setOutput('constrainees',
                                              self.deformerJoints)

        Profiler.getInstance().pop()
Exemplo n.º 10
0
    def __init__(self, name='arm', parent=None):

        Profiler.getInstance().push("Construct Arm Rig Component:" + name)
        super(ArmComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # Bicep
        self.bicepFKCtrlSpace = CtrlSpace('bicepFK', parent=self.ctrlCmpGrp)

        self.bicepFKCtrl = Control('bicepFK',
                                   parent=self.bicepFKCtrlSpace,
                                   shape="cube")
        self.bicepFKCtrl.alignOnXAxis()

        # Forearm
        self.forearmFKCtrlSpace = CtrlSpace('forearmFK',
                                            parent=self.bicepFKCtrl)

        self.forearmFKCtrl = Control('forearmFK',
                                     parent=self.forearmFKCtrlSpace,
                                     shape="cube")
        self.forearmFKCtrl.alignOnXAxis()

        self.handCtrlSpace = CtrlSpace('hand', parent=self.ctrlCmpGrp)
        self.handCtrl = Control('hand',
                                parent=self.handCtrlSpace,
                                shape="circle")
        self.handCtrl.rotatePoints(0, 0, 90)
        self.handCtrl.scalePoints(Vec3(1.0, 0.75, 0.75))

        # Arm IK
        self.armIKCtrlSpace = CtrlSpace('IK', parent=self.ctrlCmpGrp)
        self.armIKCtrl = Control('IK', parent=self.armIKCtrlSpace, shape="pin")

        # Add Params to IK control
        armSettingsAttrGrp = AttributeGroup("DisplayInfo_ArmSettings",
                                            parent=self.armIKCtrl)
        armDebugInputAttr = BoolAttribute('drawDebug',
                                          value=False,
                                          parent=armSettingsAttrGrp)
        self.armBone0LenInputAttr = ScalarAttribute('bone1Len',
                                                    value=0.0,
                                                    parent=armSettingsAttrGrp)
        self.armBone1LenInputAttr = ScalarAttribute('bone2Len',
                                                    value=0.0,
                                                    parent=armSettingsAttrGrp)
        armIKBlendInputAttr = ScalarAttribute('fkik',
                                              value=0.0,
                                              minValue=0.0,
                                              maxValue=1.0,
                                              parent=armSettingsAttrGrp)
        armSoftIKInputAttr = BoolAttribute('softIK',
                                           value=True,
                                           parent=armSettingsAttrGrp)
        armSoftDistInputAttr = ScalarAttribute('softDist',
                                               value=0.0,
                                               minValue=0.0,
                                               parent=armSettingsAttrGrp)
        armStretchInputAttr = BoolAttribute('stretch',
                                            value=True,
                                            parent=armSettingsAttrGrp)
        armStretchBlendInputAttr = ScalarAttribute('stretchBlend',
                                                   value=0.0,
                                                   minValue=0.0,
                                                   maxValue=1.0,
                                                   parent=armSettingsAttrGrp)

        # Hand Params
        handSettingsAttrGrp = AttributeGroup("DisplayInfo_HandSettings",
                                             parent=self.handCtrl)
        handLinkToWorldInputAttr = ScalarAttribute('linkToWorld',
                                                   0.0,
                                                   maxValue=1.0,
                                                   parent=handSettingsAttrGrp)

        self.drawDebugInputAttr.connect(armDebugInputAttr)

        # UpV
        self.armUpVCtrlSpace = CtrlSpace('UpV', parent=self.ctrlCmpGrp)
        self.armUpVCtrl = Control('UpV',
                                  parent=self.armUpVCtrlSpace,
                                  shape="triangle")
        self.armUpVCtrl.alignOnZAxis()
        self.armUpVCtrl.rotatePoints(180, 0, 0)

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        defCmpGrp = ComponentGroup(self.getName(), self, parent=deformersLayer)

        bicepDef = Joint('bicep', parent=defCmpGrp)
        bicepDef.setComponent(self)

        forearmDef = Joint('forearm', parent=defCmpGrp)
        forearmDef.setComponent(self)

        wristDef = Joint('wrist', parent=defCmpGrp)
        wristDef.setComponent(self)

        handDef = Joint('hand', parent=defCmpGrp)
        handDef.setComponent(self)

        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        self.armIKCtrlSpaceInputConstraint = PoseConstraint('_'.join([
            self.armIKCtrlSpace.getName(), 'To',
            self.globalSRTInputTgt.getName()
        ]))
        self.armIKCtrlSpaceInputConstraint.setMaintainOffset(True)
        self.armIKCtrlSpaceInputConstraint.addConstrainer(
            self.globalSRTInputTgt)
        self.armIKCtrlSpace.addConstraint(self.armIKCtrlSpaceInputConstraint)

        self.armUpVCtrlSpaceInputConstraint = PoseConstraint('_'.join([
            self.armUpVCtrlSpace.getName(), 'To',
            self.globalSRTInputTgt.getName()
        ]))
        self.armUpVCtrlSpaceInputConstraint.setMaintainOffset(True)
        self.armUpVCtrlSpaceInputConstraint.addConstrainer(
            self.globalSRTInputTgt)
        self.armUpVCtrlSpace.addConstraint(self.armUpVCtrlSpaceInputConstraint)

        self.armRootInputConstraint = PoseConstraint('_'.join([
            self.bicepFKCtrlSpace.getName(), 'To',
            self.clavicleEndInputTgt.getName()
        ]))
        self.armRootInputConstraint.setMaintainOffset(True)
        self.armRootInputConstraint.addConstrainer(self.clavicleEndInputTgt)
        self.bicepFKCtrlSpace.addConstraint(self.armRootInputConstraint)

        # Constraint outputs
        self.handConstraint = PoseConstraint('_'.join(
            [self.handOutputTgt.getName(), 'To',
             self.handCtrl.getName()]))
        self.handConstraint.addConstrainer(self.handCtrl)
        self.handOutputTgt.addConstraint(self.handConstraint)

        self.handCtrlSpaceConstraint = PoseConstraint('_'.join([
            self.handCtrlSpace.getName(), 'To',
            self.armEndXfoOutputTgt.getName()
        ]))
        self.handCtrlSpaceConstraint.setMaintainOffset(True)
        self.handCtrlSpaceConstraint.addConstrainer(self.armEndXfoOutputTgt)
        self.handCtrlSpace.addConstraint(self.handCtrlSpaceConstraint)

        # ===============
        # Add Splice Ops
        # ===============
        # Add Splice Op
        self.spliceOp = KLOperator('armKLOp', 'TwoBoneIKSolver', 'Kraken')
        self.addOperator(self.spliceOp)

        # Add Att Inputs
        self.spliceOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.spliceOp.setInput('rigScale', self.rigScaleInputAttr)

        self.spliceOp.setInput('bone0Len', self.armBone0LenInputAttr)
        self.spliceOp.setInput('bone1Len', self.armBone1LenInputAttr)
        self.spliceOp.setInput('ikblend', armIKBlendInputAttr)
        self.spliceOp.setInput('softIK', armSoftIKInputAttr)
        self.spliceOp.setInput('softDist', armSoftDistInputAttr)
        self.spliceOp.setInput('stretch', armStretchInputAttr)
        self.spliceOp.setInput('stretchBlend', armStretchBlendInputAttr)
        self.spliceOp.setInput('rightSide', self.rightSideInputAttr)

        # Add Xfo Inputs
        self.spliceOp.setInput('root', self.clavicleEndInputTgt)
        self.spliceOp.setInput('bone0FK', self.bicepFKCtrl)
        self.spliceOp.setInput('bone1FK', self.forearmFKCtrl)
        self.spliceOp.setInput('ikHandle', self.armIKCtrl)
        self.spliceOp.setInput('upV', self.armUpVCtrl)

        # Add Xfo Outputs
        self.spliceOp.setOutput('bone0Out', self.bicepOutputTgt)
        self.spliceOp.setOutput('bone1Out', self.forearmOutputTgt)
        self.spliceOp.setOutput('bone2Out', self.armEndXfoOutputTgt)

        # Add Deformer Splice Op
        self.outputsToDeformersKLOp = KLOperator('armDeformerKLOp',
                                                 'MultiPoseConstraintSolver',
                                                 'Kraken')
        self.addOperator(self.outputsToDeformersKLOp)

        # Add Att Inputs
        self.outputsToDeformersKLOp.setInput('drawDebug',
                                             self.drawDebugInputAttr)
        self.outputsToDeformersKLOp.setInput('rigScale',
                                             self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.outputsToDeformersKLOp.setInput('constrainers', [
            self.bicepOutputTgt, self.forearmOutputTgt,
            self.armEndXfoOutputTgt, self.handOutputTgt
        ])

        # Add Xfo Outputs
        self.outputsToDeformersKLOp.setOutput(
            'constrainees', [bicepDef, forearmDef, wristDef, handDef])

        Profiler.getInstance().pop()
Exemplo n.º 11
0
    def __init__(self, name='head', parent=None):

        Profiler.getInstance().push("Construct Head Rig Component:" + name)
        super(HeadComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # Head
        self.headCtrlSpace = CtrlSpace('head', parent=self.ctrlCmpGrp)
        self.headCtrl = Control('head',
                                parent=self.headCtrlSpace,
                                shape="circle")
        self.headCtrl.rotatePoints(0, 0, 90)
        self.headCtrl.scalePoints(Vec3(3, 3, 3))
        self.headCtrl.translatePoints(Vec3(0, 1, 0.25))

        # Eye Left
        self.eyeLeftCtrlSpace = CtrlSpace('eyeLeft', parent=self.headCtrl)
        self.eyeLeftCtrl = Control('eyeLeft',
                                   parent=self.eyeLeftCtrlSpace,
                                   shape="sphere")
        self.eyeLeftCtrl.scalePoints(Vec3(0.5, 0.5, 0.5))
        self.eyeLeftCtrl.setColor("blueMedium")

        # Eye Right
        self.eyeRightCtrlSpace = CtrlSpace('eyeRight', parent=self.headCtrl)
        self.eyeRightCtrl = Control('eyeRight',
                                    parent=self.eyeRightCtrlSpace,
                                    shape="sphere")
        self.eyeRightCtrl.scalePoints(Vec3(0.5, 0.5, 0.5))
        self.eyeRightCtrl.setColor("blueMedium")

        # Jaw
        self.jawCtrlSpace = CtrlSpace('jawCtrlSpace', parent=self.headCtrl)
        self.jawCtrl = Control('jaw', parent=self.jawCtrlSpace, shape="cube")
        self.jawCtrl.alignOnYAxis(negative=True)
        self.jawCtrl.alignOnZAxis()
        self.jawCtrl.scalePoints(Vec3(1.45, 0.65, 1.25))
        self.jawCtrl.translatePoints(Vec3(0, -0.25, 0))
        self.jawCtrl.setColor("orange")

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        defCmpGrp = ComponentGroup(self.getName(), self, parent=deformersLayer)

        headDef = Joint('head', parent=defCmpGrp)
        headDef.setComponent(self)

        jawDef = Joint('jaw', parent=defCmpGrp)
        jawDef.setComponent(self)

        eyeLeftDef = Joint('eyeLeft', parent=defCmpGrp)
        eyeLeftDef.setComponent(self)

        eyeRightDef = Joint('eyeRight', parent=defCmpGrp)
        eyeRightDef.setComponent(self)

        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        headInputConstraint = PoseConstraint('_'.join([
            self.headCtrlSpace.getName(), 'To',
            self.headBaseInputTgt.getName()
        ]))
        headInputConstraint.setMaintainOffset(True)
        headInputConstraint.addConstrainer(self.headBaseInputTgt)
        self.headCtrlSpace.addConstraint(headInputConstraint)

        # # Constraint outputs
        headOutputConstraint = PoseConstraint('_'.join(
            [self.headOutputTgt.getName(), 'To',
             self.headCtrl.getName()]))
        headOutputConstraint.addConstrainer(self.headCtrl)
        self.headOutputTgt.addConstraint(headOutputConstraint)

        jawOutputConstraint = PoseConstraint('_'.join(
            [self.jawOutputTgt.getName(), 'To',
             self.jawCtrl.getName()]))
        jawOutputConstraint.addConstrainer(self.jawCtrl)
        self.jawOutputTgt.addConstraint(jawOutputConstraint)

        eyeLOutputConstraint = PoseConstraint('_'.join(
            [self.eyeLOutputTgt.getName(), 'To',
             self.eyeLeftCtrl.getName()]))
        eyeLOutputConstraint.addConstrainer(self.eyeLeftCtrl)
        self.eyeLOutputTgt.addConstraint(eyeLOutputConstraint)

        eyeROutputConstraint = PoseConstraint('_'.join(
            [self.eyeROutputTgt.getName(), 'To',
             self.eyeRightCtrl.getName()]))
        eyeROutputConstraint.addConstrainer(self.eyeRightCtrl)
        self.eyeROutputTgt.addConstraint(eyeROutputConstraint)

        # ==================
        # Add Component I/O
        # ==================
        # Add Xfo I/O's
        # self.addInput(self.headBaseInputTgt)

        # self.addOutput(self.headOutputTgt)
        # self.addOutput(self.jawOutputTgt)
        # self.addOutput(self.eyeLOutputTgt)
        # self.addOutput(self.eyeROutputTgt)

        # Add Attribute I/O's
        # self.addInput(self.drawDebugInputAttr)

        # ===============
        # Add Splice Ops
        # ===============
        # Add Deformer Splice Op
        # spliceOp = SpliceOperator('headDeformerSpliceOp', 'HeadConstraintSolver', 'KrakenHeadConstraintSolver')
        # self.addOperator(spliceOp)

        # # Add Att Inputs
        # spliceOp.setInput('drawDebug', self.drawDebugInputAttr)
        # spliceOp.setInput('rigScale', self.rigScaleInputAttr)

        # # Add Xfo Inputstrl)
        # spliceOp.setInput('headConstrainer', self.headOutputTgt)
        # spliceOp.setInput('jawConstrainer', self.jawOutputTgt)
        # spliceOp.setInput('eyeLeftConstrainer', self.eyeLOutputTgt)
        # spliceOp.setInput('eyeRightConstrainer', self.eyeROutputTgt)

        # # Add Xfo Outputs
        # spliceOp.setOutput('headDeformer', headDef)
        # spliceOp.setOutput('jawDeformer', jawDef)
        # spliceOp.setOutput('eyeLeftDeformer', eyeLeftDef)
        # spliceOp.setOutput('eyeRightDeformer', eyeRightDef)

        Profiler.getInstance().pop()
Exemplo n.º 12
0
    def __init__(self, name='FKChain', parent=None):

        Profiler.getInstance().push("Construct FK Chain Rig Component:" + name)
        super(DyanmicChainComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        # FK
        self.fkCtrlSpaces = []
        self.fkCtrls = []
        self.setNumControls(4)

        # Add Component Params to FK control
        chainSettingsAttrGrp = AttributeGroup("DisplayInfo_ChainSettings",
                                              parent=self.fkCtrls[0])
        chainDrawDebugInputAttr = BoolAttribute('drawDebug',
                                                value=False,
                                                parent=chainSettingsAttrGrp)
        self.simulateInputAttr = BoolAttribute('simulate',
                                               value=False,
                                               parent=chainSettingsAttrGrp)
        self.resetframeInputAttr = ScalarAttribute('resetframe',
                                                   value=1,
                                                   parent=chainSettingsAttrGrp)
        self.frameInputAttr = ScalarAttribute('frame',
                                              value=0,
                                              parent=chainSettingsAttrGrp)
        self.simBlendStartInputAttr = ScalarAttribute(
            'simBlendStart',
            value=0.7,
            minValue=0.0,
            maxValue=1.0,
            parent=chainSettingsAttrGrp)
        self.simBlendEndInputAttr = ScalarAttribute(
            'simBlendEnd',
            value=1.0,
            minValue=0.0,
            maxValue=1.0,
            parent=chainSettingsAttrGrp)
        self.dampeningInputAttr = ScalarAttribute('dampening',
                                                  value=0.3,
                                                  minValue=0.0,
                                                  maxValue=1.0,
                                                  parent=chainSettingsAttrGrp)
        self.gravityInputAttr = ScalarAttribute('gravity',
                                                value=-9.8,
                                                parent=chainSettingsAttrGrp)
        self.massStartInputAttr = ScalarAttribute('massStart',
                                                  value=0.35,
                                                  minValue=0.0,
                                                  maxValue=10.0,
                                                  parent=chainSettingsAttrGrp)
        self.massEndInputAttr = ScalarAttribute('massEnd',
                                                value=1.0,
                                                minValue=0.0,
                                                maxValue=10.0,
                                                parent=chainSettingsAttrGrp)

        # Connect IO to controls
        self.drawDebugInputAttr.connect(chainDrawDebugInputAttr)

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)
        self.deformerJoints = []
        self.boneOutputsTgt = []
        self.setNumDeformers(4)

        # =====================
        # Create Component I/O
        # =====================

        # Set IO Targets
        self.boneOutputs.setTarget(self.boneOutputsTgt)

        # ==============
        # Constrain I/O
        # ==============
        # Constraint inputs
        self.rootInputConstraint = PoseConstraint('_'.join([
            self.fkCtrlSpaces[0].getName(), 'To',
            self.rootInputTgt.getName()
        ]))
        self.rootInputConstraint.setMaintainOffset(True)
        self.rootInputConstraint.addConstrainer(self.rootInputTgt)
        self.fkCtrlSpaces[0].addConstraint(self.rootInputConstraint)

        # ===============
        # Add Splice Ops
        # ===============
        # Add Output Splice Op
        self.dynamicChainKLOp = KLOperator('dynamicChainKLOp',
                                           'DynamicChainSolver', 'Kraken')
        self.addOperator(self.dynamicChainKLOp)

        # Add Att Inputs
        self.dynamicChainKLOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.dynamicChainKLOp.setInput('rigScale', self.rigScaleInputAttr)

        self.dynamicChainKLOp.setInput('simulate', self.simulateInputAttr)
        self.dynamicChainKLOp.setInput('resetframe', self.resetframeInputAttr)
        self.dynamicChainKLOp.setInput('frame', self.frameInputAttr)
        self.dynamicChainKLOp.setInput('simBlendStart',
                                       self.simBlendStartInputAttr)
        self.dynamicChainKLOp.setInput('simBlendEnd',
                                       self.simBlendEndInputAttr)
        self.dynamicChainKLOp.setInput('dampening', self.dampeningInputAttr)
        self.dynamicChainKLOp.setInput('gravity', self.gravityInputAttr)
        self.dynamicChainKLOp.setInput('massStart', self.massStartInputAttr)
        self.dynamicChainKLOp.setInput('massEnd', self.massEndInputAttr)

        # Add Xfo Inputs
        self.dynamicChainKLOp.setInput('fkPose', self.fkCtrls)

        # Add Xfo Outputs
        self.dynamicChainKLOp.setOutput('animPose', self.boneOutputsTgt)

        # Add Deformer Splice Op
        self.deformersToOutputsKLOp = KLOperator('fkChainDeformerKLOp',
                                                 'MultiPoseConstraintSolver',
                                                 'Kraken')
        self.addOperator(self.deformersToOutputsKLOp)

        # Add Att Inputs
        self.deformersToOutputsKLOp.setInput('drawDebug',
                                             self.drawDebugInputAttr)
        self.deformersToOutputsKLOp.setInput('rigScale',
                                             self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.deformersToOutputsKLOp.setInput('constrainers',
                                             self.boneOutputsTgt)

        # Add Xfo Outputs
        self.deformersToOutputsKLOp.setOutput('constrainees',
                                              self.deformerJoints)

        Profiler.getInstance().pop()
Exemplo n.º 13
0
    def __init__(self, name="foot", parent=None):

        Profiler.getInstance().push("Construct Neck Rig Component:" + name)
        super(FootComponentRig, self).__init__(name, parent)


        # =========
        # Controls
        # =========
        self.ankleLenInputAttr = ScalarAttribute('ankleLen', 1.0, maxValue=1.0, parent=self.cmpInputAttrGrp)
        self.toeLenInputAttr = ScalarAttribute('toeLen', 1.0, maxValue=1.0, parent=self.cmpInputAttrGrp)
        self.rightSideInputAttr = BoolAttribute('rightSide', False, parent=self.cmpInputAttrGrp)

        self.footAll = Locator('footAll', parent=self.ctrlCmpGrp)
        self.footAll.setShapeVisibility(False)

        self.ankleIKCtrlSpace = CtrlSpace('ankleIK', parent=self.footAll)
        self.ankleIKCtrl = Control('ankleIK', parent=self.ankleIKCtrlSpace, shape="square")
        self.ankleIKCtrl.alignOnXAxis(negative=True)
        self.ankleIKCtrl.lockTranslation(True, True, True)
        self.ankleIKCtrl.lockScale(True, True, True)

        self.toeIKCtrlSpace = CtrlSpace('toeIK', parent=self.footAll)
        self.toeIKCtrl = Control('toeIK', parent=self.toeIKCtrlSpace, shape="square")
        self.toeIKCtrl.alignOnXAxis()
        self.toeIKCtrl.lockTranslation(True, True, True)
        self.toeIKCtrl.lockScale(True, True, True)

        self.ankleFKCtrlSpace = CtrlSpace('ankleFK', parent=self.ctrlCmpGrp)
        self.ankleFKCtrl = Control('ankleFK', parent=self.ankleFKCtrlSpace, shape="cube")
        self.ankleFKCtrl.alignOnXAxis()
        self.ankleFKCtrl.lockTranslation(True, True, True)
        self.ankleFKCtrl.lockScale(True, True, True)

        self.toeFKCtrlSpace = CtrlSpace('toeFK', parent=self.ankleFKCtrl)
        self.toeFKCtrl = Control('toeFK', parent=self.toeFKCtrlSpace, shape="cube")
        self.toeFKCtrl.alignOnXAxis()
        self.toeFKCtrl.lockTranslation(True, True, True)
        self.toeFKCtrl.lockScale(True, True, True)

        self.footSettingsAttrGrp = AttributeGroup("DisplayInfo_FootSettings", parent=self.ankleIKCtrl)
        self.footDebugInputAttr = BoolAttribute('drawDebug', value=False, parent=self.footSettingsAttrGrp)
        self.footRockInputAttr = ScalarAttribute('footRock', value=0.0, minValue=-1.0, maxValue=1.0, parent=self.footSettingsAttrGrp)
        self.footBankInputAttr = ScalarAttribute('footBank', value=0.0, minValue=-1.0, maxValue=1.0, parent=self.footSettingsAttrGrp)

        self.drawDebugInputAttr.connect(self.footDebugInputAttr)

        self.pivotAll = Locator('pivotAll', parent=self.ctrlCmpGrp)
        self.pivotAll.setShapeVisibility(False)

        self.backPivotCtrl = Control('backPivot', parent=self.pivotAll, shape="axesHalfTarget")
        self.backPivotCtrl.scalePoints(Vec3(0.5, 0.5, 0.5))
        self.backPivotCtrl.lockScale(True, True, True)
        self.backPivotCtrlSpace = self.backPivotCtrl.insertCtrlSpace()

        self.frontPivotCtrl = Control('frontPivot', parent=self.pivotAll, shape="axesHalfTarget")
        self.frontPivotCtrl.rotatePoints(0.0, 180.0, 0.0)
        self.frontPivotCtrl.lockScale(True, True, True)
        self.frontPivotCtrlSpace = self.frontPivotCtrl.insertCtrlSpace()
        self.frontPivotCtrl.scalePoints(Vec3(0.5, 0.5, 0.5))

        self.outerPivotCtrl = Control('outerPivot', parent=self.pivotAll, shape="axesHalfTarget")
        self.outerPivotCtrl.rotatePoints(0.0, -90.0, 0.0)
        self.outerPivotCtrl.lockScale(True, True, True)
        self.outerPivotCtrlSpace = self.outerPivotCtrl.insertCtrlSpace()
        self.outerPivotCtrl.scalePoints(Vec3(0.5, 0.5, 0.5))

        self.innerPivotCtrl = Control('innerPivot', parent=self.pivotAll, shape="axesHalfTarget")
        self.innerPivotCtrl.rotatePoints(0.0, 90.0, 0.0)
        self.innerPivotCtrl.lockScale(True, True, True)
        self.innerPivotCtrlSpace = self.innerPivotCtrl.insertCtrlSpace()
        self.innerPivotCtrl.scalePoints(Vec3(0.5, 0.5, 0.5))


        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(), self, parent=deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)

        self.ankleDef = Joint('ankle', parent=self.defCmpGrp)
        self.ankleDef.setComponent(self)

        self.toeDef = Joint('toe', parent=self.defCmpGrp)
        self.toeDef.setComponent(self)


        # ==============
        # Constrain I/O
        # ==============
        # Constraint to inputs
        self.pivotAllInputConstraint = PoseConstraint('_'.join([self.pivotAll.getName(), 'To', self.ikHandleInputTgt.getName()]))
        self.pivotAllInputConstraint.setMaintainOffset(True)
        self.pivotAllInputConstraint.addConstrainer(self.ikHandleInputTgt)
        self.pivotAll.addConstraint(self.pivotAllInputConstraint)

        self.ankleFKInputConstraint = PoseConstraint('_'.join([self.ankleFKCtrlSpace.getName(), 'To', self.legEndFKInputTgt.getName()]))
        self.ankleFKInputConstraint.setMaintainOffset(True)
        self.ankleFKInputConstraint.addConstrainer(self.legEndFKInputTgt)
        self.ankleFKCtrlSpace.addConstraint(self.ankleFKInputConstraint)

        # Constraint outputs
        self.ikTargetOutputConstraint = PoseConstraint('_'.join([self.ikTargetOutputTgt.getName(), 'To', self.ankleIKCtrl.getName()]))
        self.ikTargetOutputConstraint.setMaintainOffset(True)
        self.ikTargetOutputConstraint.addConstrainer(self.ankleIKCtrl)
        self.ikTargetOutputTgt.addConstraint(self.ikTargetOutputConstraint)


        # =========================
        # Add Foot Pivot Canvas Op
        # =========================
        # self.footPivotCanvasOp = CanvasOperator('footPivotCanvasOp', 'Kraken.Solvers.Biped.BipedFootPivotSolver')
        self.footPivotCanvasOp = KLOperator('footPivotKLOp', 'BipedFootPivotSolver', 'Kraken')

        self.addOperator(self.footPivotCanvasOp)

        # Add Att Inputs
        self.footPivotCanvasOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.footPivotCanvasOp.setInput('rigScale', self.rigScaleInputAttr)
        self.footPivotCanvasOp.setInput('rightSide', self.rightSideInputAttr)
        self.footPivotCanvasOp.setInput('footRock', self.footRockInputAttr)
        self.footPivotCanvasOp.setInput('footBank', self.footBankInputAttr)

        # Add Xfo Inputs
        self.footPivotCanvasOp.setInput('pivotAll', self.pivotAll)
        self.footPivotCanvasOp.setInput('backPivot', self.backPivotCtrl)
        self.footPivotCanvasOp.setInput('frontPivot', self.frontPivotCtrl)
        self.footPivotCanvasOp.setInput('outerPivot', self.outerPivotCtrl)
        self.footPivotCanvasOp.setInput('innerPivot', self.innerPivotCtrl)

        # Add Xfo Outputs
        self.footPivotCanvasOp.setOutput('result', self.footAll)


        # =========================
        # Add Foot Solver Canvas Op
        # =========================
        # self.footSolverCanvasOp = CanvasOperator('footSolverCanvasOp', 'Kraken.Solvers.Biped.BipedFootSolver')
        self.footSolverCanvasOp = KLOperator('footSolverKLOp', 'BipedFootSolver', 'Kraken')
        self.addOperator(self.footSolverCanvasOp)

        # Add Att Inputs
        self.footSolverCanvasOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.footSolverCanvasOp.setInput('rigScale', self.rigScaleInputAttr)
        self.footSolverCanvasOp.setInput('ikBlend', self.ikBlendInputAttr)
        self.footSolverCanvasOp.setInput('ankleLen', self.ankleLenInputAttr)
        self.footSolverCanvasOp.setInput('toeLen', self.toeLenInputAttr)

        # Add Xfo Inputs
        self.footSolverCanvasOp.setInput('legEnd', self.legEndInputTgt)
        self.footSolverCanvasOp.setInput('ankleIK', self.ankleIKCtrl)
        self.footSolverCanvasOp.setInput('toeIK', self.toeIKCtrl)
        self.footSolverCanvasOp.setInput('ankleFK', self.ankleFKCtrl)
        self.footSolverCanvasOp.setInput('toeFK', self.toeFKCtrl)

        # Add Xfo Outputs
        self.footSolverCanvasOp.setOutput('ankle_result', self.ankleOutputTgt)
        self.footSolverCanvasOp.setOutput('toe_result', self.toeOutputTgt)


        # ===================
        # Add Deformer KL Op
        # ===================
        self.outputsToDeformersKLOp = KLOperator('foot' + self.getLocation() + 'DeformerKLOp', 'MultiPoseConstraintSolver', 'Kraken')
        self.addOperator(self.outputsToDeformersKLOp)

        # Add Att Inputs
        self.outputsToDeformersKLOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.outputsToDeformersKLOp.setInput('rigScale', self.rigScaleInputAttr)

        # Add Xfo Inputs
        self.outputsToDeformersKLOp.setInput('constrainers', [self.ankleOutputTgt, self.toeOutputTgt])

        # Add Xfo Outputs
        self.outputsToDeformersKLOp.setOutput('constrainees', [self.ankleDef, self.toeDef])

        Profiler.getInstance().pop()
Exemplo n.º 14
0
    def __init__(self, name="spine", parent=None):

        Profiler.getInstance().push("Construct Spine Rig Component:" + name)
        super(TwistComponentRig, self).__init__(name, parent)

        # =========
        # Controls
        # =========
        self.originTransform = Transform('origin', parent=self.ctrlCmpGrp)
        self.originUpVTransform = Transform('originUpV',
                                            parent=self.ctrlCmpGrp)
        self.insertTransform = Transform('insert', parent=self.ctrlCmpGrp)
        self.insertUpVTransform = Transform('insertUpV',
                                            parent=self.ctrlCmpGrp)

        # Add Params to origin transform
        twistSettings = AttributeGroup("DisplayInfo_TwistSettings",
                                       parent=self.originTransform)
        self.blendBiasInputAttr = ScalarAttribute('blendBias',
                                                  value=0.0,
                                                  minValue=0.0,
                                                  maxValue=1.0,
                                                  parent=twistSettings)

        # ==========
        # Deformers
        # ==========
        deformersLayer = self.getOrCreateLayer('deformers')
        self.defCmpGrp = ComponentGroup(self.getName(),
                                        self,
                                        parent=deformersLayer)
        self.addItem('defCmpGrp', self.defCmpGrp)
        self.deformerJoints = []
        self.twistOutputs = []
        self.setNumDeformers(1)

        # =====================
        # Create Component I/O
        # =====================
        # Setup component Xfo I/O's
        self.twistJointOutput.setTarget(self.twistOutputs)

        # ============
        # Constraints
        # ============
        # Constrain inputs

        # Origin and Insert
        constraintName = '_'.join([
            self.originTransform.getName(), 'To',
            self.originInputTgt.getName()
        ])

        self.originInputConstraint = self.originTransform.constrainTo(
            self.originInputTgt,
            constraintType='Position',
            maintainOffset=True,
            name=constraintName)

        constraintName = '_'.join([
            self.insertTransform.getName(), 'To',
            self.insertInputTgt.getName()
        ])

        self.insertInputConstraint = self.insertTransform.constrainTo(
            self.insertInputTgt,
            constraintType='Position',
            maintainOffset=True,
            name=constraintName)

        # Up Vectors
        constraintName = '_'.join([
            self.originUpVTransform.getName(), 'To',
            self.originInputTgt.getName()
        ])

        self.originUpVInputConstraint = self.originUpVTransform.constrainTo(
            self.originInputTgt,
            constraintType='Pose',
            maintainOffset=True,
            name=constraintName)

        constraintName = '_'.join([
            self.insertUpVTransform.getName(), 'To',
            self.insertInputTgt.getName()
        ])

        self.insertUpVInputConstraint = self.insertUpVTransform.constrainTo(
            self.insertInputTgt,
            constraintType='Pose',
            maintainOffset=True,
            name=constraintName)

        # Constrain outputs

        # ===============
        # Add Splice Ops
        # ===============
        # Add Spine Splice Op
        self.twistKLOp = KLOperator('TwistOp', 'TwistSolver', 'Kraken')
        self.addOperator(self.twistKLOp)

        # Add Att Inputs
        self.twistKLOp.setInput('drawDebug', self.drawDebugInputAttr)
        self.twistKLOp.setInput('rigScale', self.rigScaleInputAttr)
        self.twistKLOp.setInput('blendBias', self.blendBiasInputAttr)

        # Add Xfo Inputs
        self.twistKLOp.setInput('origin', self.originTransform)
        self.twistKLOp.setInput('originUpV', self.originUpVTransform)
        self.twistKLOp.setInput('insert', self.insertTransform)
        self.twistKLOp.setInput('insertUpV', self.insertUpVTransform)

        # Add Xfo Outputs
        self.twistKLOp.setOutput('pose', self.twistOutputs)

        # # Add Deformer Splice Op
        self.deformersToOutputsKLOp = KLOperator('twistDeformerKLOp',
                                                 'MultiPoseConstraintSolver',
                                                 'Kraken')
        self.addOperator(self.deformersToOutputsKLOp)

        # Add Att Inputs
        self.deformersToOutputsKLOp.setInput('drawDebug',
                                             self.drawDebugInputAttr)
        self.deformersToOutputsKLOp.setInput('rigScale',
                                             self.rigScaleInputAttr)

        # Add Xfo Outputs
        self.deformersToOutputsKLOp.setInput('constrainers', self.twistOutputs)

        # Add Xfo Outputs
        self.deformersToOutputsKLOp.setOutput('constrainees',
                                              self.deformerJoints)

        Profiler.getInstance().pop()