Beispiel #1
0
    def test_ik_rig_build(self):
        pos = [(0, y, 0) for y in range(15)]
        crv = pm.curve(p=pos)
        loc = pm.spaceLocator(p=(0, 0, -1))

        reg_node = ik_rig.build('temp', crv, loc, 10, 4, 'xyz')

        # Check controls connected to reg_node
        cnts = [pm.PyNode('temp%s_ik_cnt' % (x+1)) for x in range(3)]

        for c in cnts:
            attr = getattr(reg_node, c.name())
            self.assertEqual(attr.listConnections()[0].name(), c)

        # Confirm ik joint chain root connected to reg_node
        self.assertEqual(reg_node.temp_chain_root.listConnections()[0].
                         name(), 'temp_Jnt_1')

        # Confirm heirarchy
        tn = pm.PyNode('temp_ik_rig_grp')
        cnts_grp = pm.PyNode('temp_cnts_grp')
        jnts_grp = pm.PyNode('temp_ik_skin_jnts_grp')
        dont_move = pm.PyNode('temp_dont_move_grp')
        fol_grp = pm.PyNode('temp_follicle_grp')
        self.assertTrue(pm.PyNode(tn).objExists())
        self.assertTrue(
            transforms.assertParentIs(cnts_grp, tn))
        self.assertTrue(
            transforms.assertParentIs(jnts_grp, tn))
        self.assertTrue(
            transforms.assertParentIs(dont_move, tn))
        self.assertTrue(
            transforms.assertParentIs(fol_grp, tn))
Beispiel #2
0
    def test_create_heirarchy(self):
        # Test on object with parent
        jnts = []
        jnts.append(pm.joint(p=(1, 1, 1)))
        jnts.append(pm.joint(p=(2, 2, 2)))
        crv = pm.circle()[0]
        pm.delete(pm.parentConstraint(jnts[-1], crv, mo=0))
        pm.parent(crv, jnts[-1])

        grps = control.create_heirarchy('temp', crv, 5)

        count = 0
        for g in grps:
            self.assertTrue(
                transforms.assertLocationsMatch(g, crv))
            self.assertTrue(
                transforms.assertDefaultScale(g))
            if count > 0:
                self.assertTrue(
                    transforms.assertAllZero(g))
                self.assertTrue(
                    transforms.assertParentIs(g, grps[count-1]))
            count += 1

        self.assertEqual(grps[0].name(), 'temp_top_node')
        self.assertEqual(grps[-1].name(), 'temp_btm_node')
        self.assertTrue(transforms.assertParentIs(crv,
                                                  grps[-1]))
        self.assertTrue(transforms.assertParentIs(grps[0],
                                                  jnts[-1]))
        self.assertTrue(transforms.assertAllZero(crv))
        self.assertTrue(transforms.assertDefaultScale(crv))
Beispiel #3
0
 def test_assertParentIs(self):
     self.assertFalse(
         transforms.assertParentIs(self.joints[0], self.joints[1]))
     self.assertFalse(
         transforms.assertParentIs(self.joints[0], self.joints[0]))
     self.assertTrue(
         transforms.assertParentIs(self.joints[1], self.joints[0]))
     self.assertTrue(
         transforms.assertParentIs(self.joints[2], self.joints[1]))
 def test_assertParentIs(self):
     self.assertFalse(transforms.assertParentIs(self.joints[0], self.joints[1]))
     self.assertFalse(transforms.assertParentIs(self.joints[0], self.joints[0]))
     self.assertTrue(transforms.assertParentIs(self.joints[1], self.joints[0]))
     self.assertTrue(transforms.assertParentIs(self.joints[2], self.joints[1]))
    def test_combine_rig_build(self):
        pos = [(0, y, 0) for y in range(15)]
        crv = pm.curve(p=pos)
        loc = pm.spaceLocator(p=(0, 0, -1))

        reg_node = combine_rig.build(name='temp',
                                     crv=crv,
                                     loc=loc,
                                     ik_jnts=10,
                                     ik_cnts=4,
                                     ik_order='xyz',
                                     fk_order='xyz',
                                     fk_num=5,
                                     fk_buffers=2,
                                     fk_color='light_blue',
                                     fk_scale=1.0,
                                     fk_typ='cube')
        # Test sine
        ik_cnt = reg_node.tempIK1_ik_cnt.listConnections()[0]
        for a in ['wavelength', 'amplitude', 'sineOffOn',
                  'offset', 'direction']:
            print '%s.%s' % (ik_cnt, a)
            self.assertTrue(hasattr(ik_cnt, a))

        self.assertTrue(pm.PyNode('tempIK_sineDeformer').objExists())

        # Test ik
        # Check controls connected to reg_node
        cnts = [pm.PyNode('tempIK%s_ik_cnt' % (x+1)) for x in range(3)]

        for c in cnts:
            attr = getattr(reg_node, c.name())
            self.assertEqual(attr.listConnections()[0].name(), c)

        # Confirm ik joint chain root connected to reg_node
        self.assertEqual(reg_node.tempIK_chain_root.
                         listConnections()[0].name(),
                         'tempIK_Jnt_1')

        # Test fk
        cnts = ['tempFK_%s' % (x+1) for x in range(5)]
        jnts = ['tempFK_Jnt_%s' % (x+1) for x in range(5)]
        for c, j in zip(cnts, jnts):
            self.assertTrue(pm.PyNode(c).objExists())
            self.assertTrue(pm.PyNode(j).objExists())

        # Check heirarchy
        sine = reg_node.sine_handle.listConnections()[0]
        ik_top = reg_node.ik_top_node.listConnections()[0]
        fk_top = reg_node.fk_top_node.listConnections()[0]
        rig_top = reg_node.rig_top_node.listConnections()[0]

        self.assertTrue(sine.objExists())
        self.assertTrue(ik_top.objExists())
        self.assertTrue(fk_top.objExists())
        self.assertTrue(rig_top.objExists())

        self.assertTrue(transforms.
                        assertParentIs(sine.getParent(), rig_top))
        self.assertTrue(transforms.assertParentIs(ik_top, rig_top))
        self.assertTrue(transforms.assertParentIs(fk_top, rig_top))